muonroi-cli 1.8.1 → 1.8.4

package/dist/src/product-loop/__tests__/sprint-runner-phase-chunks.test.js

@@ -1,193 +0,0 @@
-/**
- * sprint-runner-phase-chunks.test.ts — P4-E unit tests.
- *
- * Phase 4 (UX): verify runSprint yields council_phase chunks for each sprint
- * stage so the TUI's CouncilPhaseTimeline shows live progress instead of going
- * silent for minutes during the planning council / implementation tool loop.
- *
- * Asserts:
- *   1. 4 phase pairs (start+done) emitted per healthy sprint
- *      (planning, implementation, verification, judgment)
- *   2. Each "active" event carries a numeric startedAt (drives live elapsed)
- *   3. phaseId is stable & unique per stage (so upsertPhase replaces in place)
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("../../council/index.js", () => ({
-    runCouncil: vi.fn(),
-}));
-vi.mock("../../verify/orchestrator.js", () => ({
-    runVerifyOrchestration: vi.fn(),
-}));
-vi.mock("../done-gate.js", () => ({
-    evaluateDoneGate: vi.fn(),
-}));
-vi.mock("../circuit-breakers.js", () => ({
-    CB1_costProjection: vi.fn(() => ({ halt: false, projection: 0, headroom: 100 })),
-    CB2_oscillation: vi.fn(() => ({ halt: false, delta_t: 0, delta_t_minus_1: 0 })),
-    CB3_verifyBlank: vi.fn(() => ({ halt: false })),
-}));
-vi.mock("../artifact-io.js", () => ({
-    appendIteration: vi.fn(),
-    readCriteria: vi.fn(async () => []),
-}));
-vi.mock("../../flow/artifact-io.js", () => ({
-    readArtifact: vi.fn(async () => null),
-    writeArtifact: vi.fn(async () => undefined),
-}));
-vi.mock("../phase-tracker-bridge.js", () => ({
-    postSprintBoundary: vi.fn(async () => undefined),
-}));
-vi.mock("../role-memory.js", () => ({
-    appendRoleMemory: vi.fn(async () => undefined),
-}));
-vi.mock("../../usage/ledger.js", () => ({
-    commitToProduct: vi.fn(async () => undefined),
-    release: vi.fn(async () => undefined),
-}));
-vi.mock("../cost-scoper.js", () => ({
-    reserveForProduct: vi.fn(async () => ({
-        id: "tok",
-        model: "m",
-        provider: "p",
-        projected_usd: 0.1,
-        est_input_tokens: 100,
-        est_output_tokens: 100,
-        createdAtMs: Date.now(),
-    })),
-}));
-vi.mock("../../providers/runtime.js", () => ({
-    detectProviderForModel: vi.fn(() => "anthropic"),
-}));
-import { runCouncil } from "../../council/index.js";
-import { runVerifyOrchestration } from "../../verify/orchestrator.js";
-import { CB3_verifyBlank } from "../circuit-breakers.js";
-import { evaluateDoneGate } from "../done-gate.js";
-import { runSprint } from "../sprint-runner.js";
-const NO_ROLES = new Map();
-function makeCtx() {
-    return {
-        runId: "run-test-phase",
-        flowDir: "/tmp/flow",
-        cwd: "/tmp/cwd",
-        idea: "test idea",
-        llm: { generate: vi.fn(async () => "synthesis text"), research: vi.fn(async () => "research") },
-        flags: { maxCost: 100, maxSprints: 5, doneThreshold: 0.9 },
-        respondToQuestion: vi.fn(),
-        respondToPreflight: vi.fn(),
-        processMessageFn: vi.fn(async function* () {
-            yield { type: "content", content: "implementing..." };
-        }),
-        detectVerifyRecipe: vi.fn(async () => ({
-            testCommands: ["npm test"],
-            coverage: 80,
-            shellInitCommands: [],
-        })),
-    };
-}
-function makeSpec() {
-    return {
-        idea: "test idea",
-        persona: "users",
-        mvp: ["feat1"],
-        phase2: [],
-        architecture: "arch",
-        ioContract: "io",
-        folderStructure: "src/",
-        sprintEstimate: 2,
-        costEstimate: 10,
-        createdAt: new Date(),
-    };
-}
-async function drain(gen) {
-    const chunks = [];
-    while (true) {
-        const { value, done } = await gen.next();
-        if (done)
-            return chunks;
-        chunks.push(value);
-    }
-}
-describe("sprint-runner emit — council_phase chunks (P4-E)", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        CB3_verifyBlank.mockReturnValue({ halt: false });
-        evaluateDoneGate.mockResolvedValue({ pass: true, score: 1.0 });
-        runVerifyOrchestration.mockResolvedValue({
-            success: true,
-            output: "VERIFY_PASS\n",
-            verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-        });
-        runCouncil.mockImplementation(async function* () {
-            yield { type: "content", content: "council planning..." };
-            return "synthesis text";
-        });
-    });
-    afterEach(() => {
-        delete globalThis.__muonroiAgentRuntime;
-    });
-    it("emits 4 active phase chunks (planning, implementation, verification, judgment) with stable phaseIds and startedAt", async () => {
-        const chunks = await drain(runSprint({
-            sprintN: 1,
-            ctx: makeCtx(),
-            productSpec: makeSpec(),
-            roleAssignments: NO_ROLES,
-            history: [],
-        }));
-        const phaseChunks = chunks.filter((c) => c.type === "council_phase" &&
-            c.councilPhase?.kind === "sprint_stage");
-        const actives = phaseChunks
-            .map((c) => c.councilPhase)
-            .filter((p) => p.state === "active");
-        expect(actives).toHaveLength(4);
-        const ids = actives.map((p) => p.phaseId).sort();
-        expect(ids).toEqual(["sprint-1-implementation", "sprint-1-judgment", "sprint-1-planning", "sprint-1-verification"]);
-        for (const p of actives) {
-            expect(typeof p.startedAt).toBe("number");
-            expect(p.startedAt).toBeGreaterThan(0);
-            expect(typeof p.label).toBe("string");
-            expect(p.label.startsWith("Sprint 1 — ")).toBe(true);
-        }
-    });
-    it("emits matching done chunks after each active, in correct order", async () => {
-        const chunks = await drain(runSprint({
-            sprintN: 2,
-            ctx: makeCtx(),
-            productSpec: makeSpec(),
-            roleAssignments: NO_ROLES,
-            history: [],
-        }));
-        const sprintPhases = chunks
-            .filter((c) => c.type === "council_phase" &&
-            c.councilPhase?.kind === "sprint_stage")
-            .map((c) => c.councilPhase);
-        // Each phaseId should appear exactly twice (active + done), in that order.
-        const seqByPhase = new Map();
-        for (const p of sprintPhases) {
-            const arr = seqByPhase.get(p.phaseId) ?? [];
-            arr.push(p.state);
-            seqByPhase.set(p.phaseId, arr);
-        }
-        for (const [id, seq] of seqByPhase.entries()) {
-            expect(seq).toEqual(["active", "done"]);
-            expect(id.startsWith("sprint-2-")).toBe(true);
-        }
-        expect(seqByPhase.size).toBe(4);
-    });
-});
-describe("phase-events helper (P4-B)", () => {
-    it("phaseStart auto-populates startedAt with current time", async () => {
-        const { phaseStart } = await import("../../council/phase-events.js");
-        const before = Date.now();
-        const chunk = phaseStart({ phaseId: "x", kind: "sprint_stage", label: "L" });
-        const after = Date.now();
-        expect(chunk.type).toBe("council_phase");
-        expect(chunk.councilPhase?.startedAt).toBeGreaterThanOrEqual(before);
-        expect(chunk.councilPhase?.startedAt).toBeLessThanOrEqual(after);
-    });
-    it("phaseStart respects explicit startedAt override (for deterministic tests)", async () => {
-        const { phaseStart } = await import("../../council/phase-events.js");
-        const chunk = phaseStart({ phaseId: "x", kind: "sprint_stage", label: "L", startedAt: 12345 });
-        expect(chunk.councilPhase?.startedAt).toBe(12345);
-    });
-});
-//# sourceMappingURL=sprint-runner-phase-chunks.test.js.map

package/dist/src/product-loop/__tests__/sprint-runner.test.d.ts

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

package/dist/src/product-loop/__tests__/sprint-runner.test.js

@@ -1,432 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// All external modules are mocked so the test exercises only sprint-runner orchestration.
-vi.mock("../../council/index.js", () => ({
-    runCouncil: vi.fn(),
-}));
-vi.mock("../../verify/orchestrator.js", () => ({
-    runVerifyOrchestration: vi.fn(),
-}));
-vi.mock("../done-gate.js", () => ({
-    evaluateDoneGate: vi.fn(),
-}));
-vi.mock("../circuit-breakers.js", () => ({
-    CB1_costProjection: vi.fn(() => ({ halt: false, projection: 0, headroom: 100 })),
-    CB2_oscillation: vi.fn(() => ({ halt: false, delta_t: 0, delta_t_minus_1: 0 })),
-    CB3_verifyBlank: vi.fn(() => ({ halt: false })),
-}));
-vi.mock("../artifact-io.js", () => ({
-    appendIteration: vi.fn(),
-    readCriteria: vi.fn(async () => []),
-}));
-vi.mock("../../flow/artifact-io.js", () => ({
-    readArtifact: vi.fn(async () => null),
-    writeArtifact: vi.fn(async () => undefined),
-}));
-vi.mock("../phase-tracker-bridge.js", () => ({
-    postSprintBoundary: vi.fn(async () => undefined),
-}));
-vi.mock("../role-memory.js", () => ({
-    appendRoleMemory: vi.fn(async () => undefined),
-}));
-vi.mock("../../usage/ledger.js", () => ({
-    commitToProduct: vi.fn(async () => undefined),
-    release: vi.fn(async () => undefined),
-}));
-vi.mock("../cost-scoper.js", () => ({
-    reserveForProduct: vi.fn(async () => ({
-        id: "tok",
-        model: "m",
-        provider: "p",
-        projected_usd: 0.1,
-        est_input_tokens: 100,
-        est_output_tokens: 100,
-        createdAtMs: Date.now(),
-    })),
-}));
-vi.mock("../../providers/runtime.js", () => ({
-    detectProviderForModel: vi.fn(() => "anthropic"),
-}));
-import { runCouncil } from "../../council/index.js";
-import { release } from "../../usage/ledger.js";
-import { CapBreachError } from "../../usage/types.js";
-import { runVerifyOrchestration } from "../../verify/orchestrator.js";
-import { appendIteration } from "../artifact-io.js";
-import { CB1_costProjection, CB2_oscillation, CB3_verifyBlank } from "../circuit-breakers.js";
-import { reserveForProduct } from "../cost-scoper.js";
-import { evaluateDoneGate } from "../done-gate.js";
-import { postSprintBoundary } from "../phase-tracker-bridge.js";
-import { runSprint } from "../sprint-runner.js";
-function makeCtx(overrides = {}) {
-    return {
-        runId: "run-123",
-        flowDir: "/tmp/flow",
-        cwd: "/tmp/cwd",
-        idea: "test idea",
-        llm: { generate: vi.fn(async () => "synthesis text"), research: vi.fn(async () => "research") },
-        flags: { maxCost: 100, maxSprints: 5, doneThreshold: 0.9 },
-        respondToQuestion: vi.fn(),
-        respondToPreflight: vi.fn(),
-        processMessageFn: vi.fn(async function* () {
-            yield { type: "content", content: "implementing..." };
-        }),
-        detectVerifyRecipe: vi.fn(async () => ({
-            testCommands: ["npm test"],
-            coverage: 80,
-            shellInitCommands: [],
-        })),
-        ...overrides,
-    };
-}
-function makeSpec() {
-    return {
-        idea: "test idea",
-        persona: "users",
-        mvp: ["feat1"],
-        phase2: [],
-        architecture: "arch",
-        ioContract: "io",
-        folderStructure: "src/",
-        sprintEstimate: 2,
-        costEstimate: 10,
-        createdAt: new Date(),
-    };
-}
-const NO_ROLES = new Map();
-async function drain(gen) {
-    const chunks = [];
-    try {
-        while (true) {
-            const { value, done } = await gen.next();
-            if (done)
-                return { chunks, result: value };
-            chunks.push(value);
-        }
-    }
-    catch (error) {
-        return { chunks, result: undefined, error };
-    }
-}
-describe("sprint-runner", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        CB1_costProjection.mockReturnValue({ halt: false, projection: 0, headroom: 100 });
-        CB2_oscillation.mockReturnValue({ halt: false, delta_t: 0, delta_t_minus_1: 0 });
-        CB3_verifyBlank.mockReturnValue({ halt: false });
-        evaluateDoneGate.mockResolvedValue({ pass: true, score: 1.0 });
-        runVerifyOrchestration.mockResolvedValue({
-            success: true,
-            output: "VERIFY_PASS\n",
-            verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-        });
-        runCouncil.mockImplementation(async function* () {
-            yield { type: "content", content: "council planning..." };
-            return "synthesis text from council";
-        });
-    });
-    it("happy path: plan → implement → verify → judge → return passing IterationState", async () => {
-        const ctx = makeCtx();
-        const gen = runSprint({
-            sprintN: 1,
-            ctx,
-            productSpec: makeSpec(),
-            roleAssignments: NO_ROLES,
-            history: [],
-        });
-        const { chunks, result } = await drain(gen);
-        expect(result).toBeDefined();
-        expect(result.sprintN).toBe(1);
-        expect(result.scoreAfter).toBe(1.0);
-        expect(result.lastVerifyResult).toBe("PASS");
-        expect(result.stage).toBe("shipped");
-        expect(runCouncil).toHaveBeenCalledTimes(1);
-        expect(ctx.processMessageFn).toHaveBeenCalled(); // implementation step
-        expect(runVerifyOrchestration).toHaveBeenCalledTimes(1);
-        expect(evaluateDoneGate).toHaveBeenCalledTimes(1);
-        expect(appendIteration).toHaveBeenCalledTimes(1);
-        expect(postSprintBoundary).toHaveBeenCalledWith(expect.objectContaining({ outcome: "pass", sprintN: 1 }));
-        expect(chunks.some((c) => c.type === "content")).toBe(true);
-    });
-    it("CB-3 trips on sprint 1 with missing recipe — yields halt chunk BEFORE planner runs", async () => {
-        CB3_verifyBlank.mockReturnValue({ halt: true, reason: "no_recipe" });
-        const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-        const { chunks, error } = await drain(runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        // Must yield a structured halt chunk, not throw.
-        expect(error).toBeUndefined();
-        const haltChunks = chunks.filter((c) => c.type === "halt");
-        expect(haltChunks).toHaveLength(1);
-        expect(haltChunks[0]).toMatchObject({
-            type: "halt",
-            haltChunk: {
-                reason: "no_recipe",
-                recovery_options: expect.arrayContaining([
-                    expect.objectContaining({ id: "init_new" }),
-                    expect.objectContaining({ id: "point_to_existing" }),
-                    expect.objectContaining({ id: "continue_as_council" }),
-                ]),
-            },
-        });
-        expect(haltChunks[0].haltChunk.recovery_options).toHaveLength(3);
-        expect(runCouncil).not.toHaveBeenCalled();
-        expect(runVerifyOrchestration).not.toHaveBeenCalled();
-    });
-    // CB-1 is intentionally disabled in sprint-runner (see comment at "Step 1").
-    // Provider pricing gaps produced false halts; re-enable once cost
-    // normalisation is reliable.
-    it.skip("CB-1 trips when projected cost exceeds 1.5x remaining headroom", async () => {
-        CB1_costProjection.mockReturnValue({ halt: true, projection: 50, headroom: 5 });
-        const ctx = makeCtx();
-        const { error } = await drain(runSprint({ sprintN: 4, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        expect(error.message).toContain("cost projection");
-        expect(runCouncil).not.toHaveBeenCalled();
-    });
-    it("CB-2 trips when last 2 deltas are non-positive at sprint >= 3", async () => {
-        CB2_oscillation.mockReturnValue({ halt: true, delta_t: -0.05, delta_t_minus_1: 0 });
-        evaluateDoneGate.mockResolvedValue({ pass: false, failedCondition: "weighted_score", score: 0.4 });
-        const history = [
-            {
-                sprintN: 3,
-                stage: "retrospective",
-                scoreBefore: 0.5,
-                scoreAfter: 0.5,
-                criteriaMet: 0,
-                criteriaPartial: 0,
-                criteriaUnmet: 0,
-                costUsd: 0,
-                lastVerifyResult: "PASS",
-            },
-            {
-                sprintN: 4,
-                stage: "retrospective",
-                scoreBefore: 0.5,
-                scoreAfter: 0.5,
-                criteriaMet: 0,
-                criteriaPartial: 0,
-                criteriaUnmet: 0,
-                costUsd: 0,
-                lastVerifyResult: "PASS",
-            },
-        ];
-        const ctx = makeCtx();
-        const { error } = await drain(runSprint({ sprintN: 5, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history }));
-        expect(error.message).toContain("oscillation");
-    });
-    it("Done-gate Cond #1 fail: returns IterationState with verify-result and continue-feedback chunk emitted", async () => {
-        evaluateDoneGate.mockResolvedValue({
-            pass: false,
-            failedCondition: "engineering_floor",
-            score: 0.4,
-            reason: "verify_FAIL",
-        });
-        runVerifyOrchestration.mockResolvedValue({
-            success: false,
-            output: "VERIFY_FAIL\nTests failed",
-            verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-        });
-        const ctx = makeCtx();
-        const { chunks, result } = await drain(runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        expect(result.stage).toBe("retrospective");
-        expect(result.lastVerifyResult).toBe("FAIL");
-        const continueChunk = chunks.find((c) => typeof c.content === "string" && c.content.includes("Next focus"));
-        expect(continueChunk).toBeDefined();
-    });
-    it("releases reservation when council generate throws (no leaked reservations)", async () => {
-        // Force the planner to call llm.generate which throws — ensure release is invoked.
-        reserveForProduct.mockResolvedValue({
-            id: "tok",
-            model: "m",
-            provider: "p",
-            projected_usd: 0.1,
-            est_input_tokens: 1,
-            est_output_tokens: 1,
-            createdAtMs: Date.now(),
-        });
-        // Make council itself yield, then trigger an error on the implementation pass.
-        runCouncil.mockImplementation(async function* () {
-            yield { type: "content", content: "planning" };
-            return "plan-text";
-        });
-        // Drive base llm.generate via product-llm wrapper inside the test indirectly:
-        // since council is mocked to NOT call llm, we simulate by directly invoking
-        // the sprint-runner happy path and then asserting release is NOT called when
-        // there is no failure. Then a separate path: cap breach.
-        const ctx = makeCtx();
-        const { result } = await drain(runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        expect(result).toBeDefined();
-        // No error, so release should NOT have been called by the wrapper.
-        expect(release).not.toHaveBeenCalled();
-    });
-    it("propagates CapBreachError as readable Error from product-LLM wrapper", async () => {
-        // Trigger reserveForProduct to return a CapBreachError during the LLM call inside the
-        // wrapper. We invoke the wrapper indirectly by having runCouncil call ctx.llm.generate
-        // through the wrapper. The simplest way is to check that the cost-scoper signals
-        // breach correctly when invoked manually — covered already by cost-scoper tests.
-        // Here we just ensure that if reserveForProduct surfaces a breach, the wrapper rethrows.
-        reserveForProduct.mockResolvedValue(new CapBreachError(40, 5, 10, 50));
-        // Simulate by importing the wrapper indirectly via runSprint: drive llm through
-        // a custom test by providing a council mock that calls llm.generate.
-        runCouncil.mockImplementation(async function* (_topic, _model, _msgs, _sid, llm) {
-            // Invoke the wrapped llm — this should throw inside the wrapper.
-            yield { type: "content", content: "planning" };
-            await llm.generate("m", "sys", "prompt");
-            return "unreachable";
-        });
-        const ctx = makeCtx();
-        const { error } = await drain(runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        expect(error.message).toMatch(/Cost cap breached/);
-    });
-});
-describe("sprint-runner phaseScope (subsystem E)", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        CB1_costProjection.mockReturnValue({ halt: false, projection: 0, headroom: 100 });
-        CB2_oscillation.mockReturnValue({ halt: false, delta_t: 0, delta_t_minus_1: 0 });
-        CB3_verifyBlank.mockReturnValue({ halt: false });
-        runVerifyOrchestration.mockResolvedValue({
-            success: true,
-            output: "VERIFY_PASS\n",
-            verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-        });
-        runCouncil.mockImplementation(async function* () {
-            yield { type: "content", content: "council planning..." };
-            return "synthesis text from council";
-        });
-    });
-    it("when phaseScope present, evaluateDoneGate receives only the scoped subset of criteria", async () => {
-        // Arrange: readCriteria returns 3 criteria; phaseScope restricts to 2 of them.
-        const { readCriteria } = await import("../artifact-io.js");
-        readCriteria.mockResolvedValue([
-            { id: "crit-A", status: "met" },
-            { id: "crit-B", status: "unmet" },
-            { id: "crit-C", status: "partial" },
-        ]);
-        evaluateDoneGate.mockResolvedValue({ pass: true, score: 1.0 });
-        const ctx = makeCtx();
-        const { result } = await drain(runSprint({
-            sprintN: 1,
-            ctx,
-            productSpec: makeSpec(),
-            roleAssignments: NO_ROLES,
-            history: [],
-            phaseScope: { criteria: ["crit-A", "crit-B"], scope: "phase-1" },
-        }));
-        expect(result).toBeDefined();
-        // evaluateDoneGate must have been called with only the 2 scoped criteria, not all 3.
-        const gateCall = evaluateDoneGate.mock.calls[0][0];
-        expect(gateCall.criteria).toHaveLength(2);
-        expect(gateCall.criteria.map((c) => c.id)).toEqual(["crit-A", "crit-B"]);
-    });
-    it("when phaseScope criteria don't match any Criterion.id, falls back to full set", async () => {
-        // Arrange: readCriteria returns 3 criteria with slug ids.
-        // phaseScope.criteria contains verbatim spec text that doesn't match any id.
-        const { readCriteria } = await import("../artifact-io.js");
-        readCriteria.mockResolvedValue([
-            { id: "crit-A", status: "met" },
-            { id: "crit-B", status: "unmet" },
-            { id: "crit-C", status: "partial" },
-        ]);
-        evaluateDoneGate.mockResolvedValue({ pass: true, score: 1.0 });
-        const ctx = makeCtx();
-        await drain(runSprint({
-            sprintN: 1,
-            ctx,
-            productSpec: makeSpec(),
-            roleAssignments: NO_ROLES,
-            history: [],
-            phaseScope: {
-                criteria: ["All API endpoints return 200", "Database migrations complete"],
-                scope: "phase-1",
-            },
-        }));
-        // None of the verbatim strings match slug ids → permissive fallback → all 3 passed.
-        const gateCall = evaluateDoneGate.mock.calls[0][0];
-        expect(gateCall.criteria).toHaveLength(3);
-    });
-    it("when phaseScope is absent, evaluateDoneGate receives all criteria (backwards-compat)", async () => {
-        const { readCriteria } = await import("../artifact-io.js");
-        readCriteria.mockResolvedValue([
-            { id: "crit-A", status: "met" },
-            { id: "crit-B", status: "unmet" },
-            { id: "crit-C", status: "partial" },
-        ]);
-        evaluateDoneGate.mockResolvedValue({ pass: true, score: 1.0 });
-        const ctx = makeCtx();
-        await drain(runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        const gateCall = evaluateDoneGate.mock.calls[0][0];
-        expect(gateCall.criteria).toHaveLength(3);
-    });
-});
-// ── Task 5.1: call-site halt forwarding ─────────────────────────────────────
-// These tests exercise runSprint() directly (the only unit-testable path for the
-// halt chunk shape and forwarding semantics). The call-site logic in index.ts
-// (sites 1, 2, 3) uses the same discriminator pattern; testing the yielded shape
-// here proves the contract that all three sites consume.
-describe("sprint-runner halt chunk forwarding (Task 5.1)", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        CB1_costProjection.mockReturnValue({ halt: false, projection: 0, headroom: 100 });
-        CB2_oscillation.mockReturnValue({ halt: false, delta_t: 0, delta_t_minus_1: 0 });
-        CB3_verifyBlank.mockReturnValue({ halt: false });
-        evaluateDoneGate.mockResolvedValue({ pass: true, score: 1.0 });
-        runVerifyOrchestration.mockResolvedValue({
-            success: true,
-            output: "VERIFY_PASS\n",
-            verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-        });
-        runCouncil.mockImplementation(async function* () {
-            yield { type: "content", content: "council planning..." };
-            return "synthesis text from council";
-        });
-    });
-    it("call site 1 pattern — CB-3 halt chunk is yielded (not thrown) and contains 3 recovery options", async () => {
-        // Simulate what site 1 (runOneSprint) drives: runSprint with sprintN=1, no history.
-        CB3_verifyBlank.mockReturnValue({ halt: true, reason: "no_recipe" });
-        const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-        const { chunks, error } = await drain(runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        // No throw — error must be undefined.
-        expect(error).toBeUndefined();
-        // Halt chunk must be in the yielded stream.
-        const halt = chunks.find((c) => c.type === "halt");
-        expect(halt).toBeDefined();
-        expect(halt).toMatchObject({ type: "halt", haltChunk: { reason: "no_recipe" } });
-        expect(halt.haltChunk.recovery_options).toHaveLength(3);
-        // Planner and verifier must NOT have run.
-        expect(runCouncil).not.toHaveBeenCalled();
-        expect(runVerifyOrchestration).not.toHaveBeenCalled();
-    });
-    it("call site 2 pattern — CB-3 halt chunk is forwarded through multi-sprint drainSprints loop", async () => {
-        // Simulate what site 2 (drainSprints) drives: runSprint with sprintN >= 1, history may be non-empty.
-        CB3_verifyBlank.mockReturnValue({ halt: true, reason: "no_recipe" });
-        const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-        // Drive with sprintN=2 to exercise the multi-sprint path in drainSprints.
-        const { chunks, error } = await drain(runSprint({ sprintN: 2, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        expect(error).toBeUndefined();
-        const halt = chunks.find((c) => c.type === "halt");
-        expect(halt).toBeDefined();
-        expect(halt).toMatchObject({ type: "halt", haltChunk: { reason: "no_recipe" } });
-        expect(halt.haltChunk.recovery_options).toHaveLength(3);
-    });
-    it("call site 3 pattern — CB-3 halt chunk is forwarded through phase-runner sprintRunner adapter", async () => {
-        // Simulate what site 3 (sprintRunner adapter inside runWithPhases) drives:
-        // runSprint called with phaseScope, no try/catch in the adapter.
-        CB3_verifyBlank.mockReturnValue({ halt: true, reason: "no_recipe" });
-        const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-        const { chunks, error } = await drain(runSprint({
-            sprintN: 1,
-            ctx,
-            productSpec: makeSpec(),
-            roleAssignments: NO_ROLES,
-            history: [],
-            phaseScope: { criteria: ["crit-A"], scope: "phase-1" },
-        }));
-        // Without the fix, the generator returned normally (halt silently consumed).
-        // With the fix, the halt chunk is in the yielded stream.
-        expect(error).toBeUndefined();
-        const halt = chunks.find((c) => c.type === "halt");
-        expect(halt).toBeDefined();
-        expect(halt).toMatchObject({ type: "halt", haltChunk: { reason: "no_recipe" } });
-        expect(halt.haltChunk.recovery_options).toHaveLength(3);
-        // Planner must NOT have been called.
-        expect(runCouncil).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=sprint-runner.test.js.map

package/dist/src/product-loop/__tests__/sprint-self-verify.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * src/product-loop/__tests__/sprint-self-verify.test.ts
- *
- * Tier 3 sprint-self-verify gate unit tests. Focus: gating logic (env flag,
- * watched-surface detection, summary parse). Does NOT actually spawn bun —
- * those paths are covered by the larger self-qa harness suite.
- */
-export {};