muonroi-cli 1.8.1 → 1.8.4

package/dist/src/product-loop/__tests__/context-policy.test.js

@@ -1,266 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { buildSprintContext, CONTEXT_CAPS, digestSprintIntoPhase, handoffPhaseToNext } from "../context-policy.js";
-const fakeProject = `## Project (permanent)\n${"x".repeat(200)}`;
-describe("buildSprintContext (subsystem E)", () => {
-    it("renders all blocks in order under cap", () => {
-        const out = buildSprintContext({
-            projectContextFormatted: fakeProject,
-            customerDecisions: [],
-            phaseHistory: [],
-            currentPhase: {
-                id: "phase-1",
-                name: "n",
-                goal: "g",
-                successCriteria: ["A"],
-                scope: "s",
-                exitCondition: { type: "criteria-threshold", min: 0.8 },
-                dependsOn: [],
-                maxSprints: 2,
-            },
-            phaseDigest: [],
-            sprintTail: "## Sprint Tail\nrecent work",
-        });
-        expect(out.indexOf("Project")).toBeLessThan(out.indexOf("Customer Decisions"));
-        expect(out.indexOf("Customer Decisions")).toBeLessThan(out.indexOf("Phase History"));
-        expect(out.indexOf("Phase History")).toBeLessThan(out.indexOf("Current Phase"));
-        expect(out.indexOf("Current Phase")).toBeLessThan(out.indexOf("Phase Digest"));
-        expect(out.indexOf("Phase Digest")).toBeLessThan(out.indexOf("Sprint Tail"));
-    });
-    it("determinism: same inputs produce same output", () => {
-        const args = {
-            projectContextFormatted: fakeProject,
-            customerDecisions: [
-                { seq: 1, timestampUtc: "2026-05-13T00:00:00Z", phaseId: "phase-1", sprintN: 1, verdict: "accept" },
-            ],
-            phaseHistory: [],
-            currentPhase: {
-                id: "phase-1",
-                name: "n",
-                goal: "g",
-                successCriteria: ["A"],
-                scope: "s",
-                exitCondition: { type: "criteria-threshold", min: 0.8 },
-                dependsOn: [],
-                maxSprints: 2,
-            },
-            phaseDigest: [{ sprintN: 1, timestampUtc: "2026-05-13T00:00:00Z", lessonText: "L" }],
-            sprintTail: "tail",
-        };
-        const a = buildSprintContext(args);
-        const b = buildSprintContext(args);
-        expect(a).toBe(b);
-    });
-    it("over cap with essentials fitting: trims sprintTail first", () => {
-        const tail = "T".repeat(20000);
-        const out = buildSprintContext({
-            projectContextFormatted: fakeProject,
-            customerDecisions: [],
-            phaseHistory: [],
-            currentPhase: {
-                id: "phase-1",
-                name: "n",
-                goal: "g",
-                successCriteria: ["A"],
-                scope: "s",
-                exitCondition: { type: "criteria-threshold", min: 0.8 },
-                dependsOn: [],
-                maxSprints: 2,
-            },
-            phaseDigest: [],
-            sprintTail: tail,
-        });
-        expect(out.length).toBeLessThanOrEqual(CONTEXT_CAPS.SPRINT_CONTEXT_BYTES + 200);
-        expect(out).toMatch(/\[…truncated \d+ bytes\]/);
-    });
-    it("project alone over cap → oversize marker", () => {
-        const huge = `## Project\n${"x".repeat(9000)}`;
-        const out = buildSprintContext({
-            projectContextFormatted: huge,
-            customerDecisions: [],
-            phaseHistory: [],
-            currentPhase: {
-                id: "phase-1",
-                name: "n",
-                goal: "g",
-                successCriteria: ["A"],
-                scope: "s",
-                exitCondition: { type: "criteria-threshold", min: 0.8 },
-                dependsOn: [],
-                maxSprints: 2,
-            },
-            phaseDigest: [],
-            sprintTail: "",
-        });
-        expect(out).toContain("[oversize:");
-        expect(out).not.toContain("Sprint Tail");
-    });
-    it("project + customer decisions together over cap → both intact + oversize marker", () => {
-        const proj = `## Project\n${"x".repeat(5000)}`;
-        const decisions = Array.from({ length: 50 }, (_, i) => ({
-            seq: i + 1,
-            timestampUtc: "2026-05-13T00:00:00Z",
-            phaseId: "phase-1",
-            sprintN: 1,
-            verdict: "reject",
-            feedback: "Y".repeat(80),
-        }));
-        const out = buildSprintContext({
-            projectContextFormatted: proj,
-            customerDecisions: decisions,
-            phaseHistory: [],
-            currentPhase: {
-                id: "phase-1",
-                name: "n",
-                goal: "g",
-                successCriteria: ["A"],
-                scope: "s",
-                exitCondition: { type: "criteria-threshold", min: 0.8 },
-                dependsOn: [],
-                maxSprints: 2,
-            },
-            phaseDigest: [],
-            sprintTail: "tail",
-        });
-        expect(out).toContain("[oversize:");
-        for (let i = 1; i <= 50; i++)
-            expect(out).toContain(`seq ${i}`);
-    });
-});
-describe("buildSprintContext truncOldestFirst history path (subsystem E)", () => {
-    const basePhase = {
-        id: "phase-1",
-        name: "n",
-        goal: "g",
-        successCriteria: ["A"],
-        scope: "s",
-        exitCondition: { type: "criteria-threshold", min: 0.8 },
-        dependsOn: [],
-        maxSprints: 2,
-    };
-    it("large phaseHistory is truncated oldest-first within cap", () => {
-        const bigHistory = Array.from({ length: 100 }, (_, i) => ({
-            phaseId: `phase-${i}`,
-            exitedAtUtc: "2026-05-13T00:00:00Z",
-            exitSummary: "S".repeat(80),
-            sprintsExecuted: 1,
-            criteriaMetCount: 1,
-        }));
-        const out = buildSprintContext({
-            projectContextFormatted: fakeProject,
-            customerDecisions: [],
-            phaseHistory: bigHistory,
-            currentPhase: basePhase,
-            phaseDigest: [],
-            sprintTail: "",
-        });
-        // should contain truncation marker and be under total cap with some slack
-        expect(out).toMatch(/\[…truncated \d+ oldest entries\]/);
-        expect(Buffer.byteLength(out, "utf8")).toBeLessThanOrEqual(CONTEXT_CAPS.SPRINT_CONTEXT_BYTES + 300);
-    });
-    it("single-entry history that is oversized: truncOldestFirst keeps one entry", () => {
-        const singleBig = [
-            {
-                phaseId: "phase-big",
-                exitedAtUtc: "2026-05-13T00:00:00Z",
-                exitSummary: "X".repeat(9000),
-                sprintsExecuted: 1,
-                criteriaMetCount: 1,
-            },
-        ];
-        const out = buildSprintContext({
-            projectContextFormatted: fakeProject,
-            customerDecisions: [],
-            phaseHistory: singleBig,
-            currentPhase: basePhase,
-            phaseDigest: [],
-            sprintTail: "",
-        });
-        // single-entry path: while loop condition `lines.length > 1` exits early, entry stays
-        expect(out).toContain("phase-big");
-    });
-});
-describe("digestSprintIntoPhase (subsystem E)", () => {
-    it("appends entry when under cap", () => {
-        const out = digestSprintIntoPhase([], { sprintN: 1, timestampUtc: "t", lessonText: "L" });
-        expect(out).toHaveLength(1);
-    });
-    it("drops oldest when over cap, adds pruned marker", () => {
-        const big = [];
-        for (let i = 0; i < 200; i++) {
-            big.push({ sprintN: i, timestampUtc: "2026-05-13T00:00:00Z", lessonText: "X".repeat(40) });
-        }
-        const out = digestSprintIntoPhase(big, { sprintN: 999, timestampUtc: "t", lessonText: "new" });
-        expect(out.length).toBeLessThan(big.length + 1);
-        expect(out[0].lessonText).toMatch(/digest pruned/);
-        expect(out[out.length - 1].sprintN).toBe(999);
-    });
-    it("preserves order: newest stays last after pruning", () => {
-        const existing = [
-            { sprintN: 1, timestampUtc: "t", lessonText: "A".repeat(2000) },
-            { sprintN: 2, timestampUtc: "t", lessonText: "B".repeat(2000) },
-        ];
-        const out = digestSprintIntoPhase(existing, { sprintN: 3, timestampUtc: "t", lessonText: "C" });
-        expect(out[out.length - 1].sprintN).toBe(3);
-    });
-    it("single oversize entry dropped, adds marker + new entry", () => {
-        const huge = [{ sprintN: 1, timestampUtc: "t", lessonText: "X".repeat(5000) }];
-        const out = digestSprintIntoPhase(huge, { sprintN: 2, timestampUtc: "t", lessonText: "tiny" });
-        expect(out.length).toBe(2);
-        expect(out[0].sprintN).toBe(-1);
-        expect(out[0].lessonText).toMatch(/digest pruned/);
-        expect(out[1].sprintN).toBe(2);
-    });
-});
-describe("handoffPhaseToNext (subsystem E)", () => {
-    it("happy path uses leader summary truncated to 300 chars", async () => {
-        const leader = {
-            generate: vi.fn().mockResolvedValue({ content: "All good carry over X.".repeat(50), costUsd: 0.05 }),
-        };
-        const out = await handoffPhaseToNext({
-            phaseId: "phase-1",
-            sprintsExecuted: 2,
-            criteriaMet: 3,
-            totalCriteria: 3,
-            leader,
-            capUsd: 10,
-            remainingUsd: 1,
-            backoffDelays: [1, 1, 1],
-        });
-        expect(out.exitSummary.length).toBeLessThanOrEqual(300);
-        expect(out.usedFallback).toBe(false);
-    });
-    it("falls back to deterministic when remainingUsd below floor", async () => {
-        const leader = { generate: vi.fn() };
-        const out = await handoffPhaseToNext({
-            phaseId: "phase-1",
-            sprintsExecuted: 2,
-            criteriaMet: 1,
-            totalCriteria: 3,
-            leader,
-            capUsd: 10,
-            remainingUsd: 0.01,
-            backoffDelays: [1, 1, 1],
-        });
-        expect(leader.generate).not.toHaveBeenCalled();
-        expect(out.usedFallback).toBe(true);
-        expect(out.exitSummary).toContain("phase-1");
-        expect(out.exitSummary).toContain("1/3");
-    });
-    it("falls back on 3 429s", async () => {
-        const err = new Error("429");
-        err.status = 429;
-        const leader = { generate: vi.fn().mockRejectedValue(err) };
-        const out = await handoffPhaseToNext({
-            phaseId: "phase-2",
-            sprintsExecuted: 5,
-            criteriaMet: 2,
-            totalCriteria: 2,
-            leader,
-            capUsd: 10,
-            remainingUsd: 1,
-            backoffDelays: [1, 1, 1],
-        });
-        expect(out.usedFallback).toBe(true);
-    });
-});
-//# sourceMappingURL=context-policy.test.js.map

package/dist/src/product-loop/__tests__/cost-preview.test.d.ts

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

package/dist/src/product-loop/__tests__/cost-preview.test.js

@@ -1,111 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DEFAULT_HEURISTIC, formatCostPreview, previewRunCost } from "../cost-preview.js";
-describe("previewRunCost", () => {
-    it("uses cached_input price when model has one (DeepSeek flash)", () => {
-        const p = previewRunCost({
-            sessionModelId: "deepseek-v4-flash",
-            maxSprints: 8,
-            capUsd: 50,
-        });
-        expect(p.pricingKnown).toBe(true);
-        expect(p.cachedInputAvailable).toBe(true);
-        expect(p.estPerSprintUsd).toBeGreaterThan(0);
-        expect(p.estTotalUsd).toBeCloseTo(p.estPerSprintUsd * 8, 5);
-        // With 70% cache hit at $0.027/M and miss at $0.27/M plus $1.10/M output,
-        // a single sprint should be well under $1.
-        expect(p.estPerSprintUsd).toBeLessThan(1);
-    });
-    it("flags willExceedCap when total > cap and recommends fewer sprints", () => {
-        const p = previewRunCost({
-            sessionModelId: "claude-3-opus-latest",
-            maxSprints: 100,
-            capUsd: 5,
-        });
-        expect(p.willExceedCap).toBe(true);
-        expect(p.recommendedMaxSprints).toBeLessThan(100);
-        expect(p.recommendedMaxSprints).toBeGreaterThanOrEqual(1);
-    });
-    it("returns pricingKnown=false for unknown model", () => {
-        const p = previewRunCost({
-            sessionModelId: "nonexistent-model-9999",
-            maxSprints: 8,
-            capUsd: 50,
-        });
-        expect(p.pricingKnown).toBe(false);
-        expect(p.estPerSprintUsd).toBe(0);
-        expect(p.estTotalUsd).toBe(0);
-        expect(p.willExceedCap).toBe(false);
-    });
-    it("ollama wildcard yields zero cost", () => {
-        const p = previewRunCost({
-            sessionModelId: "any-local-model",
-            maxSprints: 8,
-            capUsd: 50,
-        });
-        // ollama is provider-detected based on model id prefix — unknown id falls
-        // through to anthropic default. Verify the explicit ollama-prefixed case.
-        void p;
-        // Direct check for ollama "*" pricing via deepseek path is meaningless;
-        // instead verify when pricing exists, hit rate scales cost down.
-        const cached = previewRunCost({
-            sessionModelId: "gpt-4o-mini",
-            maxSprints: 4,
-            capUsd: 50,
-        });
-        const uncachedHeuristic = { ...DEFAULT_HEURISTIC, cacheHitRate: 0 };
-        const uncached = previewRunCost({
-            sessionModelId: "gpt-4o-mini",
-            maxSprints: 4,
-            capUsd: 50,
-            heuristic: uncachedHeuristic,
-        });
-        expect(cached.estPerSprintUsd).toBeLessThan(uncached.estPerSprintUsd);
-    });
-    it("formatCostPreview renders fits-cap notice on safe runs", () => {
-        const out = formatCostPreview({
-            modelId: "deepseek-v4-flash",
-            provider: "deepseek",
-            pricingKnown: true,
-            cachedInputAvailable: true,
-            estPerSprintUsd: 0.05,
-            estTotalUsd: 0.4,
-            capUsd: 50,
-            willExceedCap: false,
-            recommendedMaxSprints: 8,
-        });
-        expect(out).toContain("Cost preview");
-        expect(out).toContain("$0.05");
-        expect(out).toMatch(/fits the cap/i);
-        expect(out).toContain("prompt-cache priced");
-    });
-    it("formatCostPreview renders exceed-cap warning + recommendation", () => {
-        const out = formatCostPreview({
-            modelId: "claude-3-opus-latest",
-            provider: "anthropic",
-            pricingKnown: true,
-            cachedInputAvailable: true,
-            estPerSprintUsd: 5,
-            estTotalUsd: 40,
-            capUsd: 10,
-            willExceedCap: true,
-            recommendedMaxSprints: 2,
-        });
-        expect(out).toMatch(/exceeds.*cap/i);
-        expect(out).toContain("--max-sprints 2");
-    });
-    it("formatCostPreview surfaces unknown-pricing notice", () => {
-        const out = formatCostPreview({
-            modelId: "mystery-model",
-            provider: "unknown",
-            pricingKnown: false,
-            cachedInputAvailable: false,
-            estPerSprintUsd: 0,
-            estTotalUsd: 0,
-            capUsd: 50,
-            willExceedCap: false,
-            recommendedMaxSprints: 8,
-        });
-        expect(out).toMatch(/pricing not known/i);
-    });
-});
-//# sourceMappingURL=cost-preview.test.js.map

package/dist/src/product-loop/__tests__/cost-scoper.test.d.ts

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

package/dist/src/product-loop/__tests__/cost-scoper.test.js

@@ -1,50 +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 * as ledger from "../../usage/ledger.js";
-import * as productLedger from "../../usage/product-ledger.js";
-import { CapBreachError } from "../../usage/types.js";
-import { reserveForProduct } from "../cost-scoper.js";
-const TEST_HOME = path.join(os.tmpdir(), `muonroi-test-${Math.random().toString(36).slice(2)}`);
-describe("cost-scoper", () => {
-    beforeEach(async () => {
-        await fs.mkdir(TEST_HOME, { recursive: true });
-        vi.restoreAllMocks();
-    });
-    afterEach(async () => {
-        await fs.rm(TEST_HOME, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    it("issues reservation when both caps are fine", async () => {
-        vi.spyOn(productLedger, "getProductSpentUsd").mockResolvedValue(0.1);
-        const reserveSpy = vi.spyOn(ledger, "reserve").mockResolvedValue({
-            id: "r1",
-            model: "claude-3-5-sonnet-latest",
-            provider: "anthropic",
-            projected_usd: 0.05,
-            est_input_tokens: 100,
-            est_output_tokens: 100,
-            createdAtMs: Date.now(),
-        });
-        const result = await reserveForProduct({ provider: "anthropic", model: "claude-3-5-sonnet-latest", estInputTokens: 100, estOutputTokens: 100 }, "run-1", 1.0, TEST_HOME);
-        expect(result).not.toBeInstanceOf(CapBreachError);
-        if (!(result instanceof CapBreachError)) {
-            expect(result.productRunId).toBe("run-1");
-        }
-        expect(reserveSpy).toHaveBeenCalled();
-    });
-    it("blocks when per-product cap is hit", async () => {
-        vi.spyOn(productLedger, "getProductSpentUsd").mockResolvedValue(0.95);
-        const reserveSpy = vi.spyOn(ledger, "reserve");
-        const result = await reserveForProduct({ provider: "anthropic", model: "claude-3-5-sonnet-latest", estInputTokens: 10000, estOutputTokens: 10000 }, "run-1", 1.0, TEST_HOME);
-        expect(result instanceof CapBreachError || result.name === "CapBreachError").toBe(true);
-        expect(reserveSpy).not.toHaveBeenCalled();
-    });
-    it("blocks when monthly cap is hit", async () => {
-        vi.spyOn(productLedger, "getProductSpentUsd").mockResolvedValue(0.1);
-        vi.spyOn(ledger, "reserve").mockResolvedValue(new CapBreachError(14, 0, 2, 15));
-        const result = await reserveForProduct({ provider: "anthropic", model: "claude-3-5-sonnet-latest", estInputTokens: 100, estOutputTokens: 100 }, "run-1", 1.0, TEST_HOME);
-        expect(result instanceof CapBreachError || result.name === "CapBreachError").toBe(true);
-    });
-});
-//# sourceMappingURL=cost-scoper.test.js.map

package/dist/src/product-loop/__tests__/cross-run-memory.test.d.ts

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

package/dist/src/product-loop/__tests__/cross-run-memory.test.js

@@ -1,168 +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 { writeManifest } from "../artifact-io.js";
-import { buildPriorContext, discoverPriorRuns, formatPriorContextForPrompt } from "../cross-run-memory.js";
-function makeStubLLM(generated) {
-    return {
-        generate: vi.fn().mockResolvedValue(generated),
-        debate: vi.fn(),
-        research: vi.fn(),
-        generateObject: vi.fn(),
-    };
-}
-async function seedRun(flowDir, runId, idea, opts = {}) {
-    const createdAt = new Date(Date.now() - (opts.daysOld ?? 0) * 24 * 60 * 60 * 1000);
-    await writeManifest(flowDir, runId, {
-        idea,
-        capUsd: 50,
-        maxSprints: 8,
-        doneThreshold: 0.9,
-        createdAt,
-        verdict: opts.pass !== undefined
-            ? { pass: opts.pass, score: opts.pass ? 0.92 : 0.5, failedCondition: opts.failedCondition }
-            : undefined,
-    });
-    if (opts.memories) {
-        const memoryDir = path.join(flowDir, "runs", runId, "memory");
-        await fs.mkdir(memoryDir, { recursive: true });
-        for (const [slot, content] of Object.entries(opts.memories)) {
-            await fs.writeFile(path.join(memoryDir, `${slot}.md`), content);
-        }
-    }
-}
-describe("cross-run-memory (P5)", () => {
-    let flowDir;
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `xrm-test-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(flowDir, { recursive: true });
-    });
-    it("returns empty when no prior runs exist", async () => {
-        const runs = await discoverPriorRuns(flowDir, "current", "anything");
-        expect(runs).toEqual([]);
-    });
-    it("excludes current run from results", async () => {
-        await seedRun(flowDir, "current", "build a pdf translator extension");
-        const runs = await discoverPriorRuns(flowDir, "current", "build a pdf translator extension");
-        expect(runs).toEqual([]);
-    });
-    it("filters out low-similarity runs", async () => {
-        await seedRun(flowDir, "prior", "build a discord music bot");
-        const runs = await discoverPriorRuns(flowDir, "current", "design a database migration tool");
-        expect(runs.length).toBe(0);
-    });
-    it("keeps high-similarity runs and ranks by weight", async () => {
-        await seedRun(flowDir, "prior-recent", "pdf translator browser extension", { pass: true });
-        await seedRun(flowDir, "prior-old", "pdf translator chrome extension", {
-            pass: false,
-            failedCondition: "engineering_floor",
-            daysOld: 60,
-        });
-        const runs = await discoverPriorRuns(flowDir, "current", "pdf translator extension for brave browser");
-        expect(runs.length).toBe(2);
-        expect(runs[0].runId).toBe("prior-recent");
-        expect(runs[0].weight).toBeGreaterThan(runs[1].weight);
-        expect(runs[1].recency).toBeLessThan(runs[0].recency);
-    });
-    it("loads per-role memory files for qualifying runs", async () => {
-        await seedRun(flowDir, "prior", "pdf translator extension", {
-            pass: true,
-            memories: {
-                architect: "### Sprint 1\nChose Manifest V3 with content scripts.",
-                tester: "### Sprint 1\nUsed Playwright for e2e tests.",
-            },
-        });
-        const runs = await discoverPriorRuns(flowDir, "current", "pdf translator extension v2");
-        expect(runs.length).toBe(1);
-        expect(runs[0].memories.has("architect")).toBe(true);
-        expect(runs[0].memories.get("architect")).toContain("Manifest V3");
-    });
-    it("buildPriorContext returns empty digest when optOut=true", async () => {
-        await seedRun(flowDir, "prior", "pdf translator extension", { pass: true });
-        const llm = makeStubLLM("should not be called");
-        const result = await buildPriorContext({
-            flowDir,
-            runId: "current",
-            idea: "pdf translator extension v2",
-            leaderModelId: "leader-model",
-            llm,
-            optOut: true,
-        });
-        expect(result.digest).toBe("");
-        expect(result.runs).toEqual([]);
-        expect(llm.generate).not.toHaveBeenCalled();
-    });
-    it("buildPriorContext always returns empty digest (P1.5: leader LLM synthesis removed)", async () => {
-        await seedRun(flowDir, "prior", "pdf translator extension", {
-            pass: true,
-            memories: { architect: "Chose Manifest V3." },
-        });
-        const llm = makeStubLLM("should not be called");
-        const result = await buildPriorContext({
-            flowDir,
-            runId: "current",
-            idea: "pdf translator extension v2",
-            leaderModelId: "leader-model",
-            llm,
-        });
-        // P1.5: digest synthesis was removed — digest is always "" regardless of runs
-        expect(result.digest).toBe("");
-        expect(result.runs.length).toBe(1);
-        // leader LLM must NOT be called — PIL Layer 3 handles injection per-call
-        expect(llm.generate).not.toHaveBeenCalled();
-        const stateFile = path.join(flowDir, "runs", "current", "state.md");
-        const state = await fs.readFile(stateFile, "utf8");
-        // P1.5: section is now "EE Injections (Layer 3)" instead of "Prior Decisions Context"
-        expect(state).toContain("EE Injections (Layer 3)");
-    });
-    it("buildPriorContext persists no-injections fallback when nothing matches", async () => {
-        await seedRun(flowDir, "prior", "completely unrelated topic", { pass: true });
-        const llm = makeStubLLM("should not be called");
-        const result = await buildPriorContext({
-            flowDir,
-            runId: "current",
-            idea: "totally different idea here",
-            leaderModelId: "leader-model",
-            llm,
-        });
-        expect(result.runs.length).toBe(0);
-        expect(result.digest).toBe("");
-        expect(llm.generate).not.toHaveBeenCalled();
-        const stateFile = path.join(flowDir, "runs", "current", "state.md");
-        const state = await fs.readFile(stateFile, "utf8");
-        // P1.5: fallback text when no DB rows found
-        expect(state).toContain("no EE injections recorded yet");
-    });
-    it("formatPriorContextForPrompt returns empty for empty digest", () => {
-        expect(formatPriorContextForPrompt("")).toBe("");
-        expect(formatPriorContextForPrompt("   ")).toBe("");
-    });
-    it("formatPriorContextForPrompt wraps non-empty digest with header", () => {
-        const out = formatPriorContextForPrompt("- decision 1\n- decision 2");
-        expect(out).toContain("Prior Decisions Context");
-        expect(out).toContain("decision 1");
-        expect(out).toContain("decision 2");
-    });
-    it("LLM is never called — digest synthesis removed in P1.5", async () => {
-        await seedRun(flowDir, "prior", "pdf translator extension", { pass: true });
-        const llm = {
-            generate: vi.fn().mockRejectedValue(new Error("upstream 500")),
-            debate: vi.fn(),
-            research: vi.fn(),
-            generateObject: vi.fn(),
-        };
-        const result = await buildPriorContext({
-            flowDir,
-            runId: "current",
-            idea: "pdf translator extension v2",
-            leaderModelId: "leader-model",
-            llm,
-        });
-        // P1.5: no LLM call — always empty digest, runs still discovered
-        expect(result.digest).toBe("");
-        expect(result.runs.length).toBe(1);
-        expect(llm.generate).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=cross-run-memory.test.js.map

package/dist/src/product-loop/__tests__/design-output.spec.d.ts

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

package/dist/src/product-loop/__tests__/design-output.spec.js

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { emitDesignSpec } from "../design-output.js";
-describe("design-output", () => {
-    it("emits a valid DesignSpec for a single scene", () => {
-        const spec = emitDesignSpec({
-            scenes: [
-                {
-                    id: "composer",
-                    name: "Composer",
-                    layout: {
-                        id: "root",
-                        role: "dialog",
-                        children: [{ id: "input", role: "textbox" }],
-                    },
-                    states: [{ name: "loading", patches: [{ id: "input", state: "loading" }] }],
-                },
-            ],
-        });
-        expect(spec.mode).toBe("design");
-        expect(spec.version).toBe("0.4.0");
-        expect(spec.scenes[0].id).toBe("composer");
-    });
-    it("rejects orphan patches (id not in layout)", () => {
-        expect(() => emitDesignSpec({
-            scenes: [
-                {
-                    id: "a",
-                    name: "A",
-                    layout: { id: "root", role: "dialog" },
-                    states: [{ name: "x", patches: [{ id: "missing", state: "loading" }] }],
-                },
-            ],
-        })).toThrow(/patch references unknown id/);
-    });
-});
-//# sourceMappingURL=design-output.spec.js.map

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

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