muonroi-cli 1.8.0 → 1.8.3

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

@@ -1,140 +0,0 @@
-/**
- * src/product-loop/__tests__/sprint-planner.test.ts
- *
- * Unit tests for sprint-planner.ts.
- */
-import { mkdtemp, rm } from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { writeBacklog } from "../backlog-store.js";
-import { applySprintAssignments, planSprints } from "../sprint-planner.js";
-// ─── Mock CouncilLLM ─────────────────────────────────────────────────────────
-function makeLLM(response = '[{"sprintNumber":1,"goal":"Ship it"}]') {
-    return {
-        generate: vi.fn().mockResolvedValue(response),
-        research: vi.fn().mockResolvedValue(""),
-        debate: vi.fn().mockResolvedValue(""),
-        stream: vi.fn(),
-    };
-}
-// ─── Backlog builders ─────────────────────────────────────────────────────────
-let tmpDir;
-beforeEach(async () => {
-    tmpDir = await mkdtemp(path.join(os.tmpdir(), "sprint-planner-test-"));
-});
-afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-function makeItem(overrides) {
-    const now = new Date().toISOString();
-    return {
-        title: overrides.id,
-        description: "",
-        acceptance_criteria: ["criterion 1"],
-        entities: [],
-        endpoints: [],
-        mvp_priority: "v1",
-        status: "backlog",
-        effortPoints: 3,
-        createdAtUtc: now,
-        updatedAtUtc: now,
-        ...overrides,
-    };
-}
-function makeBacklog(items) {
-    return {
-        runId: "test-run",
-        productSlug: "test-product",
-        items,
-        derivedFromClarifyId: "abc123",
-        createdAtUtc: new Date().toISOString(),
-    };
-}
-describe("sprint-planner", () => {
-    it("3 v1 items of effort 3 each pack into 1 sprint (sum=9, within slack of 8+2)", async () => {
-        const items = [
-            makeItem({ id: "a", effortPoints: 3 }),
-            makeItem({ id: "b", effortPoints: 3 }),
-            makeItem({ id: "c", effortPoints: 3 }),
-        ];
-        const backlog = makeBacklog(items);
-        const llm = makeLLM('[{"sprintNumber":1,"goal":"Complete a, b, c"}]');
-        const plan = await planSprints({
-            runId: "test-run",
-            backlog,
-            llm: llm,
-            leaderModelId: "test-model",
-            costAware: false,
-        });
-        expect(plan.sprints).toHaveLength(1);
-        expect(plan.sprints[0].itemIds).toHaveLength(3);
-    });
-    it("6 v1 items of effort 5 each produce 3+ sprints (5 > 8+2 threshold for 2 items = 10)", async () => {
-        const items = Array.from({ length: 6 }, (_, i) => makeItem({ id: `item-${i}`, effortPoints: 5 }));
-        const backlog = makeBacklog(items);
-        const llm = makeLLM('[{"sprintNumber":1,"goal":"Sprint 1"},{"sprintNumber":2,"goal":"Sprint 2"},{"sprintNumber":3,"goal":"Sprint 3"}]');
-        const plan = await planSprints({
-            runId: "test-run",
-            backlog,
-            llm: llm,
-            leaderModelId: "test-model",
-            costAware: false,
-        });
-        // 5+5 = 10 > 10 (8+2), so each item gets its own sprint — 6 sprints.
-        // Actually 5 <= 10 so two items fit. But 5+5+5 = 15 > 10.
-        // The first two (5+5=10) fit in sprint 1 because 10 <= 10.
-        // The next two fit in sprint 2. Last two in sprint 3.
-        expect(plan.sprints.length).toBeGreaterThanOrEqual(3);
-        expect(plan.sprints.length).toBeLessThanOrEqual(6);
-    });
-    it("topo-sort: item A blocks item B → A placed before B in sprint", async () => {
-        const a = makeItem({ id: "item-a", effortPoints: 3 });
-        const b = makeItem({ id: "item-b", effortPoints: 3, blockers: ["item-a"] });
-        // Pass in reverse order to verify topo sort
-        const backlog = makeBacklog([b, a]);
-        const llm = makeLLM('[{"sprintNumber":1,"goal":"Sorted sprint"}]');
-        const plan = await planSprints({
-            runId: "test-run",
-            backlog,
-            llm: llm,
-            leaderModelId: "test-model",
-            costAware: false,
-        });
-        // Find sprint containing item-a and item-b
-        const sprintA = plan.sprints.find((s) => s.itemIds.includes("item-a"));
-        const sprintB = plan.sprints.find((s) => s.itemIds.includes("item-b"));
-        expect(sprintA.number).toBeLessThanOrEqual(sprintB.number);
-    });
-    it("pickCouncilTaskModel called with 'sprint_goal' tag — verified via LLM generate spy", async () => {
-        // We verify that LLM.generate() is called (which is what pickCouncilTaskModel routes to).
-        const items = [makeItem({ id: "a", effortPoints: 3 })];
-        const backlog = makeBacklog(items);
-        const llm = makeLLM('[{"sprintNumber":1,"goal":"Ship A"}]');
-        await planSprints({ runId: "test-run", backlog, llm: llm, leaderModelId: "test-model", costAware: true });
-        expect(llm.generate).toHaveBeenCalledOnce();
-    });
-    it("applySprintAssignments sets status=in_sprint and assigned_sprint on backlog items", async () => {
-        const items = [makeItem({ id: "a", effortPoints: 3 }), makeItem({ id: "b", effortPoints: 3 })];
-        const backlog = makeBacklog(items);
-        await writeBacklog(tmpDir, "test-run", backlog);
-        const llm = makeLLM('[{"sprintNumber":1,"goal":"Ship"}]');
-        const plan = await planSprints({
-            runId: "test-run",
-            backlog,
-            llm: llm,
-            leaderModelId: "test-model",
-            costAware: false,
-        });
-        await applySprintAssignments(tmpDir, "test-run", plan);
-        const { readBacklog } = await import("../backlog-store.js");
-        const updated = await readBacklog(tmpDir, "test-run");
-        for (const item of updated.items) {
-            if (item.mvp_priority === "v1") {
-                expect(item.status).toBe("in_sprint");
-                expect(item.assigned_sprint).toBeTruthy();
-            }
-        }
-    });
-});
-//# sourceMappingURL=sprint-planner.test.js.map

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

@@ -1,8 +0,0 @@
-/**
- * sprint-runner-backlog.test.ts — P6 smoke tests for backlog anchor injection.
- *
- * Verifies that runSprint prepends "## Active Backlog Item" to the councilTopic
- * when a backlog with in_sprint items exists for the current sprint, and does
- * NOT add the anchor when no backlog.json file is present.
- */
-export {};

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

@@ -1,221 +0,0 @@
-/**
- * sprint-runner-backlog.test.ts — P6 smoke tests for backlog anchor injection.
- *
- * Verifies that runSprint prepends "## Active Backlog Item" to the councilTopic
- * when a backlog with in_sprint items exists for the current sprint, and does
- * NOT add the anchor when no backlog.json file is present.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// All external modules mocked identically to sprint-runner-emit.test.ts pattern.
-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"),
-}));
-// Mock backlog-store to control what readBacklog returns.
-vi.mock("../backlog-store.js", () => ({
-    readBacklog: vi.fn(async () => null),
-}));
-import { runCouncil } from "../../council/index.js";
-import { runVerifyOrchestration } from "../../verify/orchestrator.js";
-import { readBacklog } from "../backlog-store.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(overrides = {}) {
-    return {
-        runId: "run-test-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(),
-    };
-}
-function makeBacklogWithInSprintItem(sprintKey = "sprint-1") {
-    const item = {
-        id: "item-abc",
-        title: "Login feature",
-        description: "Allow users to log in",
-        acceptance_criteria: ["user can log in with email"],
-        entities: [],
-        endpoints: [],
-        mvp_priority: "v1",
-        status: "in_sprint",
-        assigned_sprint: sprintKey,
-        effortPoints: 3,
-        createdAtUtc: "2026-01-01T00:00:00.000Z",
-        updatedAtUtc: "2026-01-01T00:00:00.000Z",
-    };
-    return {
-        runId: "run-test-123",
-        productSlug: "my-app",
-        items: [item],
-        derivedFromClarifyId: "abcd1234abcd1234",
-        createdAtUtc: "2026-01-01T00:00:00.000Z",
-    };
-}
-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 };
-    }
-}
-// ---------------------------------------------------------------------------
-// Setup mocks common to all tests
-// ---------------------------------------------------------------------------
-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: "planning..." };
-        return "synthesis text";
-    });
-    // Default: no backlog
-    readBacklog.mockResolvedValue(null);
-});
-afterEach(() => {
-    delete globalThis.__muonroiAgentRuntime;
-});
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("sprint-runner backlog anchor (P6)", () => {
-    it("injects 'Active Backlog Item' into councilTopic when in_sprint item exists", async () => {
-        // Arrange: backlog with 1 in_sprint item for sprint-1
-        readBacklog.mockResolvedValue(makeBacklogWithInSprintItem("sprint-1"));
-        const ctx = makeCtx();
-        await drain(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        // Assert: the first argument to runCouncil contains the backlog anchor
-        const firstCall = runCouncil.mock.calls[0];
-        expect(firstCall).toBeDefined();
-        const topic = firstCall[0];
-        expect(topic).toContain("Active Backlog Item");
-        expect(topic).toContain("Login feature");
-    });
-    it("does NOT inject 'Active Backlog Item' when backlog.json is missing", async () => {
-        // readBacklog already mocked to return null in beforeEach
-        const ctx = makeCtx();
-        await drain(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        const firstCall = runCouncil.mock.calls[0];
-        expect(firstCall).toBeDefined();
-        const topic = firstCall[0];
-        expect(topic).not.toContain("Active Backlog Item");
-    });
-    it("falls back to first v1 backlog item when no in_sprint item for this sprint", async () => {
-        // Backlog item is v1 + status=backlog (not yet assigned to a sprint)
-        const backlog = {
-            runId: "run-test-123",
-            productSlug: "my-app",
-            items: [
-                {
-                    id: "item-v1",
-                    title: "Dashboard feature",
-                    description: "Main dashboard",
-                    acceptance_criteria: ["dashboard loads in <2s"],
-                    entities: [],
-                    endpoints: [],
-                    mvp_priority: "v1",
-                    status: "backlog",
-                    effortPoints: 3,
-                    createdAtUtc: "2026-01-01T00:00:00.000Z",
-                    updatedAtUtc: "2026-01-01T00:00:00.000Z",
-                },
-            ],
-            derivedFromClarifyId: "abcd1234",
-            createdAtUtc: "2026-01-01T00:00:00.000Z",
-        };
-        readBacklog.mockResolvedValue(backlog);
-        const ctx = makeCtx();
-        await drain(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        const firstCall = runCouncil.mock.calls[0];
-        const topic = firstCall[0];
-        expect(topic).toContain("Active Backlog Item");
-        expect(topic).toContain("Dashboard feature");
-    });
-});
-//# sourceMappingURL=sprint-runner-backlog.test.js.map

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

@@ -1,14 +0,0 @@
-/**
- * sprint-runner-emit.test.ts — Phase 6.3 unit tests.
- *
- * Verifies that runSprint emits the correct harness events at each
- * sprint stage transition (planning, implementation, verification, judgment)
- * and at CB-3 halt, by mocking __muonroiAgentRuntime.
- *
- * Pattern: set globalThis.__muonroiAgentRuntime = { emitEvent: vi.fn() }
- * before running, then assert the emitEvent calls after drain.
- *
- * NOTE: 4.4 zero-overhead guarantee is also tested here — when
- * __muonroiAgentRuntime is unset, runSprint must not throw.
- */
-export {};

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

@@ -1,279 +0,0 @@
-/**
- * sprint-runner-emit.test.ts — Phase 6.3 unit tests.
- *
- * Verifies that runSprint emits the correct harness events at each
- * sprint stage transition (planning, implementation, verification, judgment)
- * and at CB-3 halt, by mocking __muonroiAgentRuntime.
- *
- * Pattern: set globalThis.__muonroiAgentRuntime = { emitEvent: vi.fn() }
- * before running, then assert the emitEvent calls after drain.
- *
- * NOTE: 4.4 zero-overhead guarantee is also tested here — when
- * __muonroiAgentRuntime is unset, runSprint must not throw.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// All external modules are mocked so this test exercises only sprint-runner
-// emit side effects, not the underlying implementations.
-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";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-const NO_ROLES = new Map();
-function makeCtx(overrides = {}) {
-    return {
-        runId: "run-test-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(),
-    };
-}
-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 };
-    }
-}
-// ---------------------------------------------------------------------------
-// Test: zero-overhead when agentRuntime is unset (Phase 4.4)
-// ---------------------------------------------------------------------------
-describe("sprint-runner emit — 4.4 zero overhead (no agentRuntime)", () => {
-    beforeEach(() => {
-        globalThis.__muonroiAgentRuntime = undefined;
-        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("runSprint completes without throwing when __muonroiAgentRuntime is unset", async () => {
-        const ctx = makeCtx();
-        const { error } = await drain(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        expect(error).toBeUndefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// Test: sprint-stage fires at all 4 stage transitions (happy path)
-// ---------------------------------------------------------------------------
-describe("sprint-runner emit — sprint-stage (all 4 stage transitions)", () => {
-    let emitEvent;
-    beforeEach(() => {
-        emitEvent = vi.fn();
-        globalThis.__muonroiAgentRuntime = { emitEvent };
-        vi.clearAllMocks();
-        emitEvent.mockClear();
-        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 sprint-stage for planning, implementation, verification, and judgment", async () => {
-        const ctx = makeCtx();
-        await drain(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        const sprintStageEvents = emitEvent.mock.calls
-            .map((call) => call[0])
-            .filter((e) => e.kind === "sprint-stage");
-        expect(sprintStageEvents).toHaveLength(4);
-        const stages = sprintStageEvents.map((e) => e.stage);
-        expect(stages).toContain("planning");
-        expect(stages).toContain("implementation");
-        expect(stages).toContain("verification");
-        expect(stages).toContain("judgment");
-        // All should reference sprint 1 and correct runId
-        for (const e of sprintStageEvents) {
-            expect(e.sprintIndex).toBe(1);
-            expect(e.runId).toBe("run-test-123");
-            expect(e.t).toBe("event");
-        }
-    });
-    it("emits stages in correct order: planning → implementation → verification → judgment", async () => {
-        const ctx = makeCtx();
-        await drain(runSprint({ sprintN: 2, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        const stageEvents = emitEvent.mock.calls
-            .map((call) => call[0])
-            .filter((e) => e.kind === "sprint-stage");
-        const stageOrder = stageEvents.map((e) => e.stage);
-        expect(stageOrder[0]).toBe("planning");
-        expect(stageOrder[1]).toBe("implementation");
-        expect(stageOrder[2]).toBe("verification");
-        expect(stageOrder[3]).toBe("judgment");
-    });
-});
-// ---------------------------------------------------------------------------
-// Test: sprint-halt fires before the halt chunk is yielded (CB-3 path)
-// ---------------------------------------------------------------------------
-describe("sprint-runner emit — sprint-halt (CB-3 gate)", () => {
-    let emitEvent;
-    beforeEach(() => {
-        emitEvent = vi.fn();
-        globalThis.__muonroiAgentRuntime = { emitEvent };
-        vi.clearAllMocks();
-        emitEvent.mockClear();
-    });
-    afterEach(() => {
-        delete globalThis.__muonroiAgentRuntime;
-    });
-    it("emits sprint-halt with correct sprintN and reason when CB-3 fires", async () => {
-        CB3_verifyBlank.mockReturnValue({
-            halt: true,
-            reason: "no_recipe",
-        });
-        const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-        const { chunks } = await drain(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-        // Verify halt chunk was yielded
-        const haltChunks = chunks.filter((c) => c.type === "halt");
-        expect(haltChunks).toHaveLength(1);
-        // Verify harness event was emitted with correct payload
-        const haltEmit = emitEvent.mock.calls
-            .map((call) => call[0])
-            .find((e) => e.kind === "sprint-halt");
-        expect(haltEmit).toBeDefined();
-        expect(haltEmit.sprintN).toBe(1);
-        expect(haltEmit.reason).toBe("no_recipe");
-        expect(haltEmit.runId).toBe("run-test-123");
-        expect(haltEmit.t).toBe("event");
-    });
-    it("sprint-halt is emitted BEFORE the halt chunk is yielded", async () => {
-        CB3_verifyBlank.mockReturnValue({
-            halt: true,
-            reason: "no_recipe",
-        });
-        const emitOrder = [];
-        const trackingEmit = vi.fn((e) => {
-            emitOrder.push(`emit:${String(e.kind)}`);
-        });
-        globalThis.__muonroiAgentRuntime = { emitEvent: trackingEmit };
-        const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-        const gen = runSprint({
-            sprintN: 1,
-            ctx: ctx,
-            productSpec: makeSpec(),
-            roleAssignments: NO_ROLES,
-            history: [],
-        });
-        const yieldOrder = [];
-        while (true) {
-            const { value, done } = await gen.next();
-            if (done)
-                break;
-            const chunk = value;
-            if (chunk.type) {
-                yieldOrder.push(`chunk:${String(chunk.type)}`);
-                // Record after each yield what emits had happened so far
-                const currentEmits = [...emitOrder];
-                if (chunk.type === "halt") {
-                    // At the point the halt chunk is yielded, sprint-halt should already be emitted
-                    expect(currentEmits).toContain("emit:sprint-halt");
-                }
-            }
-        }
-    });
-});
-//# sourceMappingURL=sprint-runner-emit.test.js.map

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

@@ -1,14 +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)
- */
-export {};