muonroi-cli 1.8.1 → 1.8.4

package/dist/src/product-loop/__tests__/discovery-recommender.test.js

@@ -1,316 +0,0 @@
-// src/product-loop/__tests__/discovery-recommender.test.ts
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { computeCostGuard, councilRecommend, leaderRecommend, shouldFallbackToLeader, withRateLimitBackoff, } from "../discovery-recommender.js";
-function makeLeader(seq) {
-    const q = [...seq];
-    return {
-        generate: vi.fn(async () => {
-            const n = q.shift();
-            if (n instanceof Error)
-                throw n;
-            return { content: n ?? "", costUsd: 0.01 };
-        }),
-    };
-}
-describe("discovery-recommender — leader", () => {
-    it("returns parsed recommendation with primary + alternatives", async () => {
-        const leader = makeLeader([
-            JSON.stringify({
-                primary: { value: "saas", rationale: "fits idea" },
-                alternatives: [
-                    { value: "internal-tool", rationale: "alt 1" },
-                    { value: "consumer-app", rationale: "alt 2" },
-                ],
-            }),
-        ]);
-        const rec = await leaderRecommend({
-            question: { id: "productType", required: true, recommendMode: "leader", prompt: "?" },
-            context: {},
-            detection: {
-                isGitRepo: false,
-                hasCommitHistory: false,
-                srcFileCount: 0,
-                manifests: [],
-                languages: [],
-                frameworks: [],
-                classification: "greenfield",
-            },
-        }, leader);
-        expect(rec.primary.value).toBe("saas");
-        expect(rec.alternatives.length).toBe(2);
-        expect(rec.source).toBe("leader");
-        expect(rec.costUsd).toBeGreaterThan(0);
-    });
-    it("retries once on malformed JSON", async () => {
-        const leader = makeLeader([
-            "bad",
-            JSON.stringify({ primary: { value: "saas", rationale: "x" }, alternatives: [] }),
-        ]);
-        const rec = await leaderRecommend({
-            question: { id: "productType", required: true, recommendMode: "leader", prompt: "?" },
-            context: {},
-            detection: {},
-        }, leader);
-        expect(rec.primary.value).toBe("saas");
-        expect(leader.generate).toHaveBeenCalledTimes(2);
-    });
-    it("falls back to user-only after two failures", async () => {
-        const leader = makeLeader(["bad", "bad"]);
-        const rec = await leaderRecommend({
-            question: { id: "productType", required: true, recommendMode: "leader", prompt: "?" },
-            context: {},
-            detection: {},
-        }, leader);
-        expect(rec.source).toBe("user-only");
-    });
-});
-describe("discovery-recommender — council", () => {
-    it("synthesizes recommendation from chunks where 2-of-3 stances agree", async () => {
-        const fakeDebate = {
-            async *runDebate() {
-                yield { type: "stance", name: "pragmatist", value: "monolith", rationale: "simple" };
-                yield { type: "stance", name: "scaler", value: "monolith", rationale: "ok for scale" };
-                yield { type: "stance", name: "cost-optimizer", value: "microservices", rationale: "isolate" };
-                yield { type: "cost", costUsd: 0.3 };
-            },
-        };
-        const leader = makeLeader([]);
-        const rec = await councilRecommend({
-            question: { id: "backendArchitecture", required: true, recommendMode: "council", prompt: "?" },
-            context: {},
-            detection: { classification: "greenfield" },
-        }, leader, fakeDebate);
-        expect(rec.primary.value).toBe("monolith");
-        expect(rec.alternatives.length).toBe(1);
-        expect(rec.source).toBe("council");
-        expect(rec.tiebreakUsed).toBe(false);
-        expect(rec.costUsd).toBeCloseTo(0.3, 2);
-    });
-    it("invokes synth tiebreak when all three stances differ", async () => {
-        const fakeDebate = {
-            async *runDebate() {
-                yield { type: "stance", name: "pragmatist", value: "monolith", rationale: "simple" };
-                yield { type: "stance", name: "scaler", value: "microservices", rationale: "scale" };
-                yield { type: "stance", name: "cost-optimizer", value: "serverless", rationale: "cheap" };
-                yield { type: "cost", costUsd: 0.3 };
-            },
-        };
-        const leader = makeLeader([
-            JSON.stringify({
-                primary: { value: "monolith", rationale: "synth: best fit" },
-                alternatives: [
-                    { value: "microservices", rationale: "alt" },
-                    { value: "serverless", rationale: "alt" },
-                ],
-            }),
-        ]);
-        const rec = await councilRecommend({
-            question: { id: "backendArchitecture", required: true, recommendMode: "council", prompt: "?" },
-            context: {},
-            detection: { classification: "greenfield" },
-        }, leader, fakeDebate);
-        expect(rec.tiebreakUsed).toBe(true);
-        expect(rec.primary.value).toBe("monolith");
-        expect(rec.synthFailed).toBeFalsy();
-    });
-    it("falls back to highest-confidence when synth fails", async () => {
-        const fakeDebate = {
-            async *runDebate() {
-                yield { type: "stance", name: "pragmatist", value: "monolith", rationale: "simple", confidence: 0.7 };
-                yield { type: "stance", name: "scaler", value: "microservices", rationale: "scale", confidence: 0.4 };
-                yield { type: "stance", name: "cost-optimizer", value: "serverless", rationale: "cheap", confidence: 0.5 };
-                yield { type: "cost", costUsd: 0.3 };
-            },
-        };
-        const leader = makeLeader(["bad json", "still bad"]);
-        const rec = await councilRecommend({
-            question: { id: "backendArchitecture", required: true, recommendMode: "council", prompt: "?" },
-            context: {},
-            detection: { classification: "greenfield" },
-        }, leader, fakeDebate);
-        expect(rec.tiebreakUsed).toBe(true);
-        expect(rec.synthFailed).toBe(true);
-        expect(rec.primary.value).toBe("monolith"); // highest confidence
-    });
-    it("falls back to leader when council throws", async () => {
-        const fakeDebate = {
-            // biome-ignore lint/correctness/useYield: test stub — always throws, never yields
-            async *runDebate() {
-                throw new Error("council unavailable");
-            },
-        };
-        const leader = makeLeader([
-            JSON.stringify({ primary: { value: "monolith", rationale: "leader fallback" }, alternatives: [] }),
-        ]);
-        const rec = await councilRecommend({
-            question: { id: "backendArchitecture", required: true, recommendMode: "council", prompt: "?" },
-            context: {},
-            detection: { classification: "greenfield" },
-        }, leader, fakeDebate);
-        expect(rec.source).toBe("leader");
-        expect(rec.primary.value).toBe("monolith");
-    });
-});
-describe("discovery-recommender — MUONROI_DEBUG_LEADER instrumentation", () => {
-    const baseInput = {
-        question: { id: "productType", required: true, recommendMode: "leader", prompt: "What type?" },
-        context: {},
-        detection: {
-            isGitRepo: false,
-            hasCommitHistory: false,
-            srcFileCount: 0,
-            manifests: [],
-            languages: [],
-            frameworks: [],
-            classification: "greenfield",
-        },
-    };
-    let stderrLines = [];
-    let stderrSpy;
-    let originalDebug;
-    beforeEach(() => {
-        originalDebug = process.env.MUONROI_DEBUG_LEADER;
-        process.env.MUONROI_DEBUG_LEADER = "1";
-        stderrLines = [];
-        stderrSpy = vi.spyOn(process.stderr, "write").mockImplementation((chunk) => {
-            if (typeof chunk === "string")
-                stderrLines.push(chunk);
-            return true;
-        });
-    });
-    afterEach(() => {
-        stderrSpy.mockRestore();
-        if (originalDebug === undefined) {
-            delete process.env.MUONROI_DEBUG_LEADER;
-        }
-        else {
-            process.env.MUONROI_DEBUG_LEADER = originalDebug;
-        }
-    });
-    it("emits two [leader-debug] parse_fail lines when leader returns invalid responses twice", async () => {
-        // attempt 0: truncated fenced JSON — stripFences strips fences but JSON.parse fails
-        const markdownFenced = '```json\n{"primary":{"value":"saas"'; // truncated — no closing braces
-        // attempt 1: missing `value` field → parseLeaderResponse returns null
-        const truncated = '{"primary":{"rationale":"x"}}';
-        const leader = makeLeader([markdownFenced, truncated]);
-        const rec = await leaderRecommend(baseInput, leader);
-        expect(rec.source).toBe("user-only");
-        const debugLines = stderrLines.filter((l) => l.startsWith("[leader-debug] "));
-        expect(debugLines).toHaveLength(2);
-        const parsed0 = JSON.parse(debugLines[0].replace("[leader-debug] ", "").trim());
-        expect(parsed0.attempt).toBe(0);
-        expect(parsed0.outcome).toBe("parse_fail");
-        expect(parsed0.rawResponse).toBe(markdownFenced);
-        expect(parsed0).toHaveProperty("model");
-        expect(parsed0).toHaveProperty("system");
-        expect(parsed0).toHaveProperty("prompt");
-        expect(typeof parsed0.system).toBe("string");
-        expect(parsed0.system.length).toBeLessThanOrEqual(500);
-        expect(parsed0.prompt.length).toBeLessThanOrEqual(500);
-        const parsed1 = JSON.parse(debugLines[1].replace("[leader-debug] ", "").trim());
-        expect(parsed1.attempt).toBe(1);
-        expect(parsed1.outcome).toBe("parse_fail");
-        expect(parsed1.rawResponse).toBe(truncated);
-    });
-    it("emits one [leader-debug] parse_ok line when leader returns valid JSON", async () => {
-        const validResponse = JSON.stringify({
-            primary: { value: "saas", rationale: "good fit" },
-            alternatives: [{ value: "b2b", rationale: "alt" }],
-        });
-        const leader = makeLeader([validResponse]);
-        const rec = await leaderRecommend(baseInput, leader);
-        expect(rec.source).toBe("leader");
-        expect(rec.primary.value).toBe("saas");
-        const debugLines = stderrLines.filter((l) => l.startsWith("[leader-debug] "));
-        expect(debugLines).toHaveLength(1);
-        const parsed = JSON.parse(debugLines[0].replace("[leader-debug] ", "").trim());
-        expect(parsed.attempt).toBe(0);
-        expect(parsed.outcome).toBe("parse_ok");
-        expect(parsed.rawResponse).toBe(validResponse);
-    });
-    it("does NOT emit [leader-debug] lines when MUONROI_DEBUG_LEADER is unset", async () => {
-        delete process.env.MUONROI_DEBUG_LEADER;
-        const leader = makeLeader(["bad", "bad"]);
-        await leaderRecommend(baseInput, leader);
-        const debugLines = stderrLines.filter((l) => l.startsWith("[leader-debug] "));
-        expect(debugLines).toHaveLength(0);
-    });
-});
-describe("discovery-recommender — 401 fast-fail", () => {
-    const baseInput = {
-        question: { id: "productType", required: true, recommendMode: "leader", prompt: "What type?" },
-        context: {},
-        detection: {
-            isGitRepo: false,
-            hasCommitHistory: false,
-            srcFileCount: 0,
-            manifests: [],
-            languages: [],
-            frameworks: [],
-            classification: "greenfield",
-        },
-    };
-    it("does NOT call generate a second time when attempt 0 throws a 401 status error", async () => {
-        const unauthorizedErr = Object.assign(new Error("Unauthorized"), { status: 401 });
-        const leader = makeLeader([unauthorizedErr]);
-        // makeLeader only has one item — if attempt 1 fires it would throw "shift from empty"
-        // we spy to assert call count explicitly
-        const generateSpy = vi.spyOn(leader, "generate");
-        const rec = await leaderRecommend(baseInput, leader);
-        expect(generateSpy).toHaveBeenCalledTimes(1);
-        expect(rec.source).toBe("user-only");
-        expect(rec.primary.rationale).toBe("leader unavailable; awaiting user");
-    });
-    it("does NOT call generate a second time when attempt 0 throws a statusCode 401 error", async () => {
-        const unauthorizedErr = Object.assign(new Error("HTTP 401 Unauthorized"), { statusCode: 401 });
-        const leader = makeLeader([unauthorizedErr]);
-        const generateSpy = vi.spyOn(leader, "generate");
-        const rec = await leaderRecommend(baseInput, leader);
-        expect(generateSpy).toHaveBeenCalledTimes(1);
-        expect(rec.source).toBe("user-only");
-    });
-    it("DOES retry on a non-401 error (e.g. network timeout)", async () => {
-        const networkErr = new Error("ECONNRESET");
-        const leader = makeLeader([
-            networkErr,
-            JSON.stringify({ primary: { value: "saas", rationale: "ok" }, alternatives: [] }),
-        ]);
-        const rec = await leaderRecommend(baseInput, leader);
-        expect(rec.source).toBe("leader");
-        expect(rec.primary.value).toBe("saas");
-    });
-});
-describe("discovery-recommender — cost guard + 429", () => {
-    it("guard = max($2.50, 0.15 * capUsd)", () => {
-        expect(computeCostGuard(0)).toBe(2.5);
-        expect(computeCostGuard(10)).toBe(2.5);
-        expect(computeCostGuard(20)).toBe(3.0);
-        expect(computeCostGuard(50)).toBe(7.5);
-    });
-    it("shouldFallbackToLeader trips when cumulative + estimate exceeds guard", () => {
-        expect(shouldFallbackToLeader({ cumulative: 0, capUsd: 50 })).toBe(false);
-        expect(shouldFallbackToLeader({ cumulative: 7.2, capUsd: 50 })).toBe(true); // 7.20 + 0.45 > 7.50
-        expect(shouldFallbackToLeader({ cumulative: 2.1, capUsd: 10 })).toBe(true); // 2.10 + 0.45 > 2.50
-    });
-    it("withRateLimitBackoff retries 429 and succeeds on third attempt", async () => {
-        const fn = vi
-            .fn()
-            .mockRejectedValueOnce(Object.assign(new Error("rate"), { status: 429 }))
-            .mockRejectedValueOnce(Object.assign(new Error("rate"), { status: 429 }))
-            .mockResolvedValueOnce("ok");
-        const result = await withRateLimitBackoff(fn, { delays: [1] });
-        expect(result).toBe("ok");
-        expect(fn).toHaveBeenCalledTimes(3);
-    });
-    it("withRateLimitBackoff gives up after maxRetries attempts", async () => {
-        const fn = vi.fn().mockRejectedValue(Object.assign(new Error("rate"), { status: 429 }));
-        await expect(withRateLimitBackoff(fn, { delays: [1] })).rejects.toThrow();
-        expect(fn).toHaveBeenCalledTimes(3); // maxRetries=3 total attempts
-    });
-    it("withRateLimitBackoff does not retry non-429 errors", async () => {
-        const fn = vi.fn().mockRejectedValue(new Error("network"));
-        await expect(withRateLimitBackoff(fn, { delays: [1] })).rejects.toThrow("network");
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=discovery-recommender.test.js.map

package/dist/src/product-loop/__tests__/discovery-schema.test.d.ts

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

package/dist/src/product-loop/__tests__/discovery-schema.test.js

@@ -1,77 +0,0 @@
-// src/product-loop/__tests__/discovery-schema.test.ts
-import { describe, expect, it } from "vitest";
-import { DISCOVERY_QUESTIONS, getSchemaHintForLeader, isAgentHarnessAccepted, isFePolicyAccepted, isRequiredForPlatform, OPTIONAL_QUESTION_IDS, REQUIRED_QUESTION_IDS, validateAnswer, } from "../discovery-schema.js";
-describe("discovery-schema", () => {
-    it("has exactly 10 questions", () => {
-        expect(DISCOVERY_QUESTIONS).toHaveLength(10);
-    });
-    it("identifies 6 required questions", () => {
-        expect(REQUIRED_QUESTION_IDS.length).toBe(6);
-        expect(REQUIRED_QUESTION_IDS).toContain("productType");
-        expect(REQUIRED_QUESTION_IDS).toContain("backendArchitecture");
-    });
-    it("identifies 4 optional questions", () => {
-        expect(OPTIONAL_QUESTION_IDS.length).toBe(4);
-    });
-    it("marks big-4 council questions correctly", () => {
-        const big4 = DISCOVERY_QUESTIONS.filter((q) => q.recommendMode === "council").map((q) => q.id);
-        expect(big4).toEqual(["backendArchitecture", "backendStack", "dbStrategy", "deployment"]);
-    });
-    it("accepts headless UI library values", () => {
-        expect(isFePolicyAccepted("shadcn")).toBe(true);
-        expect(isFePolicyAccepted("radix")).toBe(true);
-        expect(isFePolicyAccepted("headlessui")).toBe(true);
-        expect(isFePolicyAccepted("none")).toBe(true);
-    });
-    it("rejects image-based UI values", () => {
-        expect(isFePolicyAccepted("figma-import")).toBe(false);
-        expect(isFePolicyAccepted("image-derived")).toBe(false);
-        expect(isFePolicyAccepted("custom-from-screenshot")).toBe(false);
-    });
-    it("requires frontendApproach when platform includes web", () => {
-        expect(isRequiredForPlatform("frontendApproach", ["web"])).toBe(true);
-        expect(isRequiredForPlatform("frontendApproach", ["cli"])).toBe(false);
-        expect(isRequiredForPlatform("frontendApproach", ["mobile-ios"])).toBe(false);
-    });
-    it("validates productType against enum", () => {
-        expect(validateAnswer("productType", "saas").ok).toBe(true);
-        expect(validateAnswer("productType", "nonsense").ok).toBe(false);
-    });
-    it("validates audience requires persona+scale+geography", () => {
-        expect(validateAnswer("audience", { persona: "devs", scale: "1k-100k", geography: "SEA" }).ok).toBe(true);
-        expect(validateAnswer("audience", { persona: "devs" }).ok).toBe(false);
-    });
-    it("frontendApproach.agentHarness — accepts all five wrapper values", () => {
-        expect(isAgentHarnessAccepted("react")).toBe(true);
-        expect(isAgentHarnessAccepted("angular")).toBe(true);
-        expect(isAgentHarnessAccepted("opentui")).toBe(true);
-        expect(isAgentHarnessAccepted("core")).toBe(true);
-        expect(isAgentHarnessAccepted("none")).toBe(true);
-    });
-    it("frontendApproach.agentHarness — rejects unknown wrapper values", () => {
-        expect(isAgentHarnessAccepted("vue")).toBe(false);
-        expect(isAgentHarnessAccepted("svelte")).toBe(false);
-        expect(isAgentHarnessAccepted("")).toBe(false);
-    });
-    it("validateAnswer frontendApproach — accepts when agentHarness omitted (back-compat)", () => {
-        expect(validateAnswer("frontendApproach", { library: "shadcn", framework: "next" }).ok).toBe(true);
-    });
-    it("validateAnswer frontendApproach — accepts when agentHarness is a known wrapper", () => {
-        expect(validateAnswer("frontendApproach", { library: "shadcn", framework: "next", agentHarness: "react" }).ok).toBe(true);
-    });
-    it("validateAnswer frontendApproach — rejects when agentHarness is a bogus wrapper", () => {
-        const result = validateAnswer("frontendApproach", { library: "shadcn", framework: "next", agentHarness: "vue" });
-        expect(result.ok).toBe(false);
-        expect(result.reason).toMatch(/agentHarness/);
-    });
-    it("schema hint mentions the agentHarness slot and all five wrapper values", () => {
-        const hint = getSchemaHintForLeader("frontendApproach");
-        expect(hint).toContain("agentHarness");
-        expect(hint).toContain('"react"');
-        expect(hint).toContain('"angular"');
-        expect(hint).toContain('"opentui"');
-        expect(hint).toContain('"core"');
-        expect(hint).toContain('"none"');
-    });
-});
-//# sourceMappingURL=discovery-schema.test.js.map

package/dist/src/product-loop/__tests__/done-gate-coverage.test.d.ts

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

package/dist/src/product-loop/__tests__/done-gate-coverage.test.js

@@ -1,135 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { evaluateDoneGate } from "../done-gate.js";
-import { VERIFY_PASS_MARKER } from "../verify-result.js";
-function buildBaseCtx(overrides = {}) {
-    const roleAssignments = new Map();
-    roleAssignments.set("PO", { modelId: "gpt-4", provider: "openai", tier: "pro" });
-    roleAssignments.set("Customer", { modelId: "claude-3", provider: "anthropic", tier: "pro" });
-    return {
-        recipe: { testCommands: ["npm test"], coverage: 0.8, ecosystem: "node" },
-        lastVerify: { success: true, output: VERIFY_PASS_MARKER },
-        criteria: [{ id: "f", status: "met", evidence: "src/x.ts:1" }],
-        history: [],
-        roleAssignments,
-        llm: { generate: vi.fn().mockResolvedValue("SHIP") },
-        respondToPreflight: vi.fn().mockResolvedValue(true),
-        doneThreshold: 0.9,
-        ...overrides,
-    };
-}
-describe("evaluateDoneGate — coverage gaps", () => {
-    beforeEach(() => {
-        delete process.env.MUONROI_DEV;
-    });
-    it("fails Cond #1 with reason=no_test_commands when recipe has empty testCommands", () => {
-        return evaluateDoneGate(buildBaseCtx({ recipe: { testCommands: [], coverage: 0.5, ecosystem: "node" } })).then((v) => {
-            expect(v.pass).toBe(false);
-            expect(v.failedCondition).toBe("engineering_floor");
-            expect(v.reason).toBe("no_test_commands");
-        });
-    });
-    it("fails Cond #1 when lastVerify is undefined (no verify run yet)", async () => {
-        const v = await evaluateDoneGate(buildBaseCtx({ lastVerify: undefined }));
-        expect(v.pass).toBe(false);
-        expect(v.failedCondition).toBe("engineering_floor");
-        expect(v.reason).toBe("verify_FAIL");
-    });
-    it("clamps doneThreshold below 0.7 up to 0.7", async () => {
-        // Build criteria producing exactly 0.7 — would fail with threshold=0.9 but pass when clamped
-        const ctx = buildBaseCtx({
-            doneThreshold: 0.1, // clamped → 0.7
-            criteria: [
-                { id: "a", status: "met", evidence: "f.ts:1" },
-                { id: "b", status: "met", evidence: "f.ts:2" },
-                { id: "c", status: "met", evidence: "f.ts:3" },
-                { id: "d", status: "met", evidence: "f.ts:4" },
-                { id: "e", status: "met", evidence: "f.ts:5" },
-                { id: "f", status: "met", evidence: "f.ts:6" },
-                { id: "g", status: "met", evidence: "f.ts:7" },
-                { id: "h", status: "unmet" },
-                { id: "i", status: "unmet" },
-                { id: "j", status: "unmet" },
-            ],
-            // Tier-different so debate runs (but score 0.7 < 0.85 → R5 skip)
-        });
-        const v = await evaluateDoneGate(ctx);
-        expect(v.score).toBeCloseTo(0.7, 5);
-        expect(v.pass).toBe(true); // 0.7 == clamped threshold → not below → passes Cond #3
-    });
-    it("clamps doneThreshold above 1.0 down to 1.0", async () => {
-        const ctx = buildBaseCtx({
-            doneThreshold: 5,
-            criteria: [{ id: "a", status: "partial", evidence: "f.ts:1" }], // score=0.5
-        });
-        const v = await evaluateDoneGate(ctx);
-        expect(v.pass).toBe(false);
-        expect(v.failedCondition).toBe("weighted_score");
-    });
-    it("returns score=0 when criteria array is empty (still fails Cond #3)", async () => {
-        const v = await evaluateDoneGate(buildBaseCtx({ criteria: [], doneThreshold: 0.7 }));
-        expect(v.score).toBe(0);
-        expect(v.failedCondition).toBe("weighted_score");
-    });
-    it("Cond #2: criterion with status=unmet does not need evidence", async () => {
-        const ctx = buildBaseCtx({
-            doneThreshold: 0.7,
-            criteria: [
-                { id: "a", status: "met", evidence: "f.ts:1" },
-                { id: "b", status: "met", evidence: "f.ts:2" },
-                { id: "c", status: "met", evidence: "f.ts:3" },
-                { id: "d", status: "unmet" }, // no evidence → fine
-            ],
-        });
-        const v = await evaluateDoneGate(ctx);
-        expect(v.pass).toBe(true);
-        expect(v.score).toBe(0.75);
-    });
-    it("Cond #4: PO missing returns missing_roles", async () => {
-        // Force debate by ensuring score >= 0.85
-        const ctx = buildBaseCtx({
-            criteria: [
-                { id: "a", status: "met", evidence: "f.ts:1" },
-                { id: "b", status: "met", evidence: "f.ts:2" },
-            ],
-        });
-        ctx.roleAssignments.delete("PO");
-        const v = await evaluateDoneGate(ctx);
-        expect(v.pass).toBe(false);
-        expect(v.failedCondition).toBe("customer_debate");
-        expect(v.reason).toBe("missing_roles");
-    });
-    it("Cond #4: cross-provider runs single round (1 PO + 1 Customer + 1 final = 3 LLM calls)", async () => {
-        const llm = { generate: vi.fn().mockResolvedValue("SHIP") };
-        const ctx = buildBaseCtx({ llm });
-        const v = await evaluateDoneGate(ctx);
-        expect(v.pass).toBe(true);
-        expect(llm.generate).toHaveBeenCalledTimes(3);
-    });
-    it("Cond #4: same-provider different-tier runs 3 rounds (3*2 + 1 = 7 calls)", async () => {
-        const llm = { generate: vi.fn().mockResolvedValue("SHIP") };
-        const ctx = buildBaseCtx({ llm });
-        ctx.roleAssignments.set("PO", { modelId: "gpt-4", provider: "openai", tier: "pro" });
-        ctx.roleAssignments.set("Customer", { modelId: "gpt-4o", provider: "openai", tier: "balanced" });
-        const v = await evaluateDoneGate(ctx);
-        expect(v.pass).toBe(true);
-        expect(llm.generate).toHaveBeenCalledTimes(7);
-    });
-    it("Cond #4: same-provider same-tier different-model runs 5 rounds (5*2 + 1 = 11 calls)", async () => {
-        const llm = { generate: vi.fn().mockResolvedValue("SHIP") };
-        const ctx = buildBaseCtx({ llm });
-        ctx.roleAssignments.set("PO", { modelId: "gpt-4", provider: "openai", tier: "pro" });
-        ctx.roleAssignments.set("Customer", { modelId: "gpt-4-32k", provider: "openai", tier: "pro" });
-        const v = await evaluateDoneGate(ctx);
-        expect(v.pass).toBe(true);
-        expect(llm.generate).toHaveBeenCalledTimes(11);
-    });
-    it("Cond #4: WAIT decision without explicit reason returns customer_dissent", async () => {
-        const llm = {
-            generate: vi.fn().mockResolvedValueOnce("po").mockResolvedValueOnce("cust").mockResolvedValueOnce("WAIT:"), // empty reason
-        };
-        const v = await evaluateDoneGate(buildBaseCtx({ llm }));
-        expect(v.pass).toBe(false);
-        expect(v.reason).toBe("customer_dissent");
-    });
-});
-//# sourceMappingURL=done-gate-coverage.test.js.map

package/dist/src/product-loop/__tests__/done-gate.test.d.ts

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

package/dist/src/product-loop/__tests__/done-gate.test.js

@@ -1,122 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { evaluateDoneGate } from "../done-gate.js";
-import { VERIFY_PASS_MARKER } from "../verify-result.js";
-describe("evaluateDoneGate", () => {
-    let ctx;
-    let mockLlm;
-    let mockRespondToPreflight;
-    beforeEach(() => {
-        mockLlm = {
-            generate: vi.fn().mockResolvedValue("SHIP"),
-        };
-        mockRespondToPreflight = vi.fn().mockResolvedValue(true);
-        const roleAssignments = new Map();
-        roleAssignments.set("PO", { modelId: "gpt-4", provider: "openai", tier: "pro" });
-        roleAssignments.set("Customer", { modelId: "claude-3", provider: "anthropic", tier: "pro" });
-        ctx = {
-            recipe: {
-                testCommands: ["npm test"],
-                coverage: 0.8,
-                ecosystem: "node",
-            },
-            lastVerify: {
-                success: true,
-                output: VERIFY_PASS_MARKER,
-            },
-            criteria: [{ id: "feat-1", status: "met", evidence: "src/feat1.ts:10" }],
-            history: [],
-            roleAssignments,
-            llm: mockLlm,
-            respondToPreflight: mockRespondToPreflight,
-            doneThreshold: 0.9,
-        };
-    });
-    it("passes happy path (all 5 conditions)", async () => {
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(true);
-        expect(verdict.score).toBe(1.0);
-    });
-    it("fails Cond #1: engineering_floor (no recipe)", async () => {
-        ctx.recipe = null;
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("engineering_floor");
-        expect(verdict.reason).toBe("no_recipe");
-    });
-    it("fails Cond #1: engineering_floor (zero coverage)", async () => {
-        if (ctx.recipe)
-            ctx.recipe.coverage = 0;
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("engineering_floor");
-        expect(verdict.reason).toBe("zero_coverage");
-    });
-    it("fails Cond #1: engineering_floor (verify FAIL)", async () => {
-        ctx.lastVerify = { success: false, output: "FAIL" };
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("engineering_floor");
-        expect(verdict.reason).toBe("verify_FAIL");
-    });
-    it("fails Cond #2: evidence_regex (missing evidence)", async () => {
-        ctx.criteria[0].evidence = "we did it"; // invalid evidence
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("evidence_regex");
-        expect(verdict.reason).toContain("missing_evidence");
-    });
-    it("fails Cond #3: weighted_score (below threshold)", async () => {
-        ctx.criteria = [{ id: "feat-1", status: "partial", evidence: "src/feat1.ts:10" }]; // score 0.5
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("weighted_score");
-        expect(verdict.score).toBe(0.5);
-    });
-    it("fails Cond #4: customer_debate (echo_chamber)", async () => {
-        ctx.roleAssignments.set("Customer", { modelId: "gpt-4", provider: "openai", tier: "pro" });
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("customer_debate");
-        expect(verdict.reason).toBe("echo_chamber");
-    });
-    it("fails Cond #4: customer_debate (dissent)", async () => {
-        mockLlm.generate
-            .mockResolvedValueOnce("PO explanation")
-            .mockResolvedValueOnce("Customer doubt")
-            .mockResolvedValueOnce("WAIT: some bug");
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("customer_debate");
-        expect(verdict.reason).toBe("some bug");
-    });
-    it("skips Cond #4: customer_debate when MUONROI_DEV=1", async () => {
-        process.env.MUONROI_DEV = "1";
-        ctx.roleAssignments.set("Customer", { modelId: "gpt-4", provider: "openai", tier: "pro" }); // normally would fail echo_chamber
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(true); // Should pass because debate is skipped
-        delete process.env.MUONROI_DEV;
-    });
-    it("skips Cond #4: customer_debate when score < 0.85 (R5 skip)", async () => {
-        ctx.criteria = [
-            { id: "f1", status: "met", evidence: "f.ts:1" },
-            { id: "f2", status: "met", evidence: "f.ts:2" },
-            { id: "f3", status: "met", evidence: "f.ts:3" },
-            { id: "f4", status: "met", evidence: "f.ts:4" },
-            { id: "f5", status: "met", evidence: "f.ts:5" },
-            { id: "f6", status: "partial", evidence: "f.ts:6" }, // score = 5.5 / 6 = 0.916
-        ];
-        ctx.doneThreshold = 0.7; // Lower threshold to pass Cond #3
-        // Now make it < 0.85
-        ctx.criteria.push({ id: "f7", status: "unmet" }); // score = 5.5 / 7 = 0.785
-        ctx.roleAssignments.set("Customer", { modelId: "gpt-4", provider: "openai", tier: "pro" }); // echo_chamber if debate runs
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(true); // Should pass because debate is skipped (score 0.785 < 0.85)
-    });
-    it("fails Cond #5: user_approval (rejection)", async () => {
-        mockRespondToPreflight.mockResolvedValue(false);
-        const verdict = await evaluateDoneGate(ctx);
-        expect(verdict.pass).toBe(false);
-        expect(verdict.failedCondition).toBe("user_approval");
-    });
-});
-//# sourceMappingURL=done-gate.test.js.map