muonroi-cli 1.8.1 → 1.8.4

package/dist/src/product-loop/__tests__/role-registry.test.js

@@ -1,222 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveRoles } from "../role-registry.js";
-const mockInventory = [
-    {
-        id: "gpt-4o",
-        name: "GPT-4o",
-        provider: "openai",
-        tier: "premium",
-        contextWindow: 128000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "",
-    },
-    {
-        id: "gpt-4o-mini",
-        name: "GPT-4o Mini",
-        provider: "openai",
-        tier: "balanced",
-        contextWindow: 128000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "",
-    },
-    {
-        id: "claude-3-5-sonnet",
-        name: "Claude 3.5 Sonnet",
-        provider: "anthropic",
-        tier: "premium",
-        contextWindow: 200000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "",
-    },
-    {
-        id: "claude-3-haiku",
-        name: "Claude 3 Haiku",
-        provider: "anthropic",
-        tier: "balanced",
-        contextWindow: 200000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "",
-    },
-    {
-        id: "o1",
-        name: "o1",
-        provider: "openai",
-        tier: "premium",
-        contextWindow: 128000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: true,
-        description: "",
-    },
-    {
-        id: "o1-mini",
-        name: "o1-mini",
-        provider: "openai",
-        tier: "balanced",
-        contextWindow: 128000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: true,
-        description: "",
-    },
-    {
-        id: "llama-3-70b",
-        name: "Llama 3 70b",
-        provider: "meta",
-        tier: "balanced",
-        contextWindow: 8000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "",
-    },
-    {
-        id: "llama-3-8b",
-        name: "Llama 3 8b",
-        provider: "meta",
-        tier: "fast",
-        contextWindow: 8000,
-        inputPrice: 0,
-        outputPrice: 0,
-        reasoning: false,
-        description: "",
-    },
-];
-describe("role-registry resolution", () => {
-    it("assigns cross-provider for PO and Customer when available", async () => {
-        const result = await resolveRoles({ inventory: mockInventory });
-        if (result.kind !== "ok")
-            throw new Error("Expected ok result");
-        expect(result.roles.PO.provider).not.toBe(result.roles.Customer.provider);
-        expect(result.roles.PO.model).not.toBe(result.roles.Customer.model);
-        expect(result.sameProvider).toBe(false);
-    });
-    it("assigns different models on same provider when only one provider has enough models", async () => {
-        const singleProviderInventory = mockInventory.filter((m) => m.provider === "openai");
-        // openai has gpt-4o, gpt-4o-mini, o1, o1-mini (4 models)
-        // We need 6 models for a successful run.
-        const inventoryWith6Models = [
-            ...singleProviderInventory,
-            {
-                id: "gpt-3.5-turbo",
-                name: "GPT-3.5",
-                provider: "openai",
-                tier: "fast",
-                contextWindow: 16000,
-                inputPrice: 0,
-                outputPrice: 0,
-                reasoning: false,
-                description: "",
-            },
-            {
-                id: "gpt-4-turbo",
-                name: "GPT-4 Turbo",
-                provider: "openai",
-                tier: "premium",
-                contextWindow: 128000,
-                inputPrice: 0,
-                outputPrice: 0,
-                reasoning: false,
-                description: "",
-            },
-        ];
-        const result = await resolveRoles({ inventory: inventoryWith6Models });
-        if (result.kind !== "ok")
-            throw new Error("Expected ok result");
-        expect(result.roles.PO.provider).toBe("openai");
-        expect(result.roles.Customer.provider).toBe("openai");
-        expect(result.roles.PO.model).not.toBe(result.roles.Customer.model);
-        expect(result.sameProvider).toBe(true);
-        const modelIds = Object.values(result.roles).map((r) => r.model);
-        const uniqueModels = new Set(modelIds);
-        expect(uniqueModels.size).toBe(6);
-    });
-    it("refuses if single provider has only 5 models", async () => {
-        const inventoryWith5Models = mockInventory
-            .filter((m) => m.provider === "openai")
-            .concat([
-            {
-                id: "gpt-3.5-turbo",
-                name: "GPT-3.5",
-                provider: "openai",
-                tier: "fast",
-                contextWindow: 16000,
-                inputPrice: 0,
-                outputPrice: 0,
-                reasoning: false,
-                description: "",
-            },
-        ]);
-        expect(inventoryWith5Models.length).toBe(5);
-        const result = await resolveRoles({ inventory: inventoryWith5Models });
-        expect(result.kind).toBe("refuse");
-        if (result.kind === "refuse") {
-            expect(result.reason).toBe("single_provider_too_few");
-        }
-    });
-    it("honors tier preferences when ample models available", async () => {
-        const result = await resolveRoles({ inventory: mockInventory });
-        if (result.kind !== "ok")
-            throw new Error("Expected ok result");
-        // PO preference: premium, balanced
-        expect(["premium", "balanced"]).toContain(result.roles.PO.tier);
-        // Implementer preference: balanced, fast, premium
-        expect(["balanced", "fast", "premium"]).toContain(result.roles.Implementer.tier);
-        // Tester preference: balanced, premium
-        expect(["balanced", "premium"]).toContain(result.roles.Tester.tier);
-    });
-    it("applies EE override when provided and valid", async () => {
-        const eeRouteOverride = async (slot) => {
-            if (slot === "PO") {
-                return {
-                    model: "claude-3-5-sonnet",
-                    tier: "premium",
-                    confidence: 1,
-                    source: "ee",
-                    reason: "override",
-                    taskHash: "123",
-                };
-            }
-            return null;
-        };
-        const result = await resolveRoles({ inventory: mockInventory, eeRouteOverride });
-        if (result.kind !== "ok")
-            throw new Error("Expected ok result");
-        expect(result.roles.PO.model).toBe("claude-3-5-sonnet");
-        expect(result.roles.PO.source).toBe("ee");
-    });
-    it("ignores EE override if model is not in inventory", async () => {
-        const eeRouteOverride = async (slot) => {
-            if (slot === "PO") {
-                return {
-                    model: "non-existent-model",
-                    tier: "premium",
-                    confidence: 1,
-                    source: "ee",
-                    reason: "override",
-                    taskHash: "123",
-                };
-            }
-            return null;
-        };
-        const result = await resolveRoles({ inventory: mockInventory, eeRouteOverride });
-        if (result.kind !== "ok")
-            throw new Error("Expected ok result");
-        expect(result.roles.PO.model).not.toBe("non-existent-model");
-        expect(result.roles.PO.source).toBe("cold-start");
-    });
-    it("is idempotent and deterministic", async () => {
-        const result1 = await resolveRoles({ inventory: mockInventory });
-        const result2 = await resolveRoles({ inventory: mockInventory });
-        expect(result1).toEqual(result2);
-    });
-});
-//# sourceMappingURL=role-registry.test.js.map

package/dist/src/product-loop/__tests__/role-routing-ee.test.d.ts

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

package/dist/src/product-loop/__tests__/role-routing-ee.test.js

@@ -1,79 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { resolveRoles } from "../role-registry.js";
-const inventory = [
-    { id: "anthropic-premium-1", provider: "anthropic", tier: "premium" },
-    { id: "openai-premium-1", provider: "openai", tier: "premium" },
-    { id: "openai-balanced-1", provider: "openai", tier: "balanced" },
-    { id: "google-balanced-1", provider: "google", tier: "balanced" },
-    { id: "deepseek-fast-1", provider: "deepseek", tier: "fast" },
-    { id: "siliconflow-balanced-1", provider: "siliconflow", tier: "balanced" },
-];
-describe("resolveRoles + EE override", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("applies eeRouteOverride to mark assignment source=ee", async () => {
-        const eeRouteOverride = vi.fn(async (slot) => {
-            if (slot === "Implementer") {
-                return {
-                    tier: "fast",
-                    model: "deepseek-fast-1",
-                    confidence: 0.9,
-                    source: "history",
-                    reason: "past success",
-                    taskHash: "h1",
-                };
-            }
-            return null;
-        });
-        const result = await resolveRoles({ inventory, eeRouteOverride });
-        expect(result.kind).toBe("ok");
-        if (result.kind === "ok") {
-            expect(result.roles.Implementer.model).toBe("deepseek-fast-1");
-            expect(result.roles.Implementer.source).toBe("ee");
-            // Other slots fall back to cold-start
-            expect(result.roles.PO.source).toBe("cold-start");
-        }
-        // EE override called for every slot (registry asks per slot)
-        expect(eeRouteOverride).toHaveBeenCalled();
-    });
-    it("ignores EE override when model is not in inventory", async () => {
-        const eeRouteOverride = vi.fn(async () => ({
-            tier: "premium",
-            model: "ghost-model-not-in-inventory",
-            confidence: 0.99,
-            source: "history",
-            reason: "phantom",
-            taskHash: "h",
-        }));
-        const result = await resolveRoles({ inventory, eeRouteOverride });
-        expect(result.kind).toBe("ok");
-        if (result.kind === "ok") {
-            // Every slot must remain cold-start because the EE-suggested model is unknown
-            for (const slot of Object.keys(result.roles)) {
-                expect(result.roles[slot].source).toBe("cold-start");
-            }
-        }
-    });
-    it("does not collapse PO/Customer onto same model when EE picks one for both", async () => {
-        const eeRouteOverride = vi.fn(async (slot) => {
-            if (slot === "PO" || slot === "Customer") {
-                return {
-                    tier: "premium",
-                    model: "anthropic-premium-1",
-                    confidence: 0.95,
-                    source: "history",
-                    reason: "best",
-                    taskHash: "h",
-                };
-            }
-            return null;
-        });
-        const result = await resolveRoles({ inventory, eeRouteOverride });
-        expect(result.kind).toBe("ok");
-        if (result.kind === "ok") {
-            expect(result.roles.PO.model).not.toBe(result.roles.Customer.model);
-        }
-    });
-});
-//# sourceMappingURL=role-routing-ee.test.js.map

package/dist/src/product-loop/__tests__/route-decision-emit.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * route-decision-emit.test.ts — Phase 6.4 unit tests.
- *
- * Verifies that runHotPath and runStart emit the route-decision harness event
- * with the correct `path` field, by mocking __muonroiAgentRuntime.
- *
- * runHotPath is accessed via runProductLoop with complexity="low".
- * runStart is accessed via runProductLoop with complexity="high".
- */
-export {};

package/dist/src/product-loop/__tests__/route-decision-emit.test.js

@@ -1,222 +0,0 @@
-/**
- * route-decision-emit.test.ts — Phase 6.4 unit tests.
- *
- * Verifies that runHotPath and runStart emit the route-decision harness event
- * with the correct `path` field, by mocking __muonroiAgentRuntime.
- *
- * runHotPath is accessed via runProductLoop with complexity="low".
- * runStart is accessed via runProductLoop with complexity="high".
- */
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { getTestModels } from "../../__test-helpers__/catalog-fixtures.js";
-import { loadCatalog } from "../../models/registry.js";
-vi.mock("../sprint-runner.js", () => ({
-    runSprint: vi.fn(),
-}));
-vi.mock("../cross-run-memory.js", () => ({
-    extractRunToEE: vi.fn(async () => ({ ok: true, durationMs: 1, mistakes: 0, stored: 1 })),
-}));
-vi.mock("../../ee/phase-outcome.js", () => ({
-    fireAndForgetPhaseOutcome: vi.fn(),
-}));
-// runStart calls runLoopDriver which eventually calls llm/council — stub the
-// parts that would fail in a unit test context by making runSprint resolve
-// immediately to simulate the full sprint cycle.
-vi.mock("../loop-driver.js", () => ({
-    runLoopDriver: vi.fn(),
-}));
-// A2: mock backlog/sprint-plan I/O so buildBacklogAndSprintPlan returns quickly.
-vi.mock("../backlog-store.js", () => ({
-    readBacklog: vi.fn(async () => null),
-    writeBacklog: vi.fn(async () => undefined),
-}));
-vi.mock("../sprint-store.js", () => ({
-    readSprintPlan: vi.fn(async () => null),
-    writeSprintPlan: vi.fn(async () => undefined),
-    setActiveSprint: vi.fn(async () => undefined),
-}));
-vi.mock("../backlog-builder.js", () => ({
-    buildBacklog: vi.fn(async () => ({
-        runId: "test-run",
-        productSlug: "test",
-        items: [],
-        derivedFromClarifyId: "abc123",
-        createdAtUtc: new Date().toISOString(),
-    })),
-}));
-vi.mock("../sprint-planner.js", () => ({
-    planSprints: vi.fn(async () => ({
-        runId: "test-run",
-        sprints: [{ id: "sprint-1", number: 1, goal: "go", itemIds: [], status: "planned" }],
-        createdAtUtc: new Date().toISOString(),
-    })),
-    applySprintAssignments: vi.fn(async () => undefined),
-}));
-// Dynamic imports inside buildBacklogAndSprintPlan
-vi.mock("../discovery-persistence.js", () => ({
-    readProjectContext: vi.fn(async () => null),
-}));
-vi.mock("../gather.js", () => ({
-    clarifiedSpecFromContext: vi.fn(() => ({
-        problemStatement: "test",
-        constraints: [],
-        successCriteria: [],
-        scope: "test",
-        rawQA: [],
-        resolved: {},
-    })),
-}));
-import { runProductLoop } from "../index.js";
-import { runLoopDriver } from "../loop-driver.js";
-import { runSprint } from "../sprint-runner.js";
-beforeAll(async () => {
-    await loadCatalog();
-});
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-async function tmpFlowDir() {
-    return fs.mkdtemp(path.join(os.tmpdir(), "route-dec-emit-"));
-}
-async function drain(gen) {
-    const chunks = [];
-    while (true) {
-        const { value, done } = await gen.next();
-        if (done)
-            return { chunks, result: value };
-        chunks.push(value);
-    }
-}
-function shippedIter(sprintN = 1) {
-    return {
-        sprintN,
-        stage: "shipped",
-        scoreBefore: 0,
-        scoreAfter: 1.0,
-        criteriaMet: 1,
-        criteriaPartial: 0,
-        criteriaUnmet: 0,
-        costUsd: 0.1,
-        lastVerifyResult: "PASS",
-    };
-}
-function makeOpts(flowDir, overrides = {}) {
-    return {
-        flowDir,
-        idea: "build something",
-        subcommand: "start",
-        sessionModelId: getTestModels().balanced,
-        sessionId: "test-session-id",
-        llm: { generate: vi.fn(async () => ""), research: vi.fn(async () => "") },
-        flags: { maxCost: 50, maxSprints: 8, doneThreshold: 0.9 },
-        respondToQuestion: vi.fn(async () => "answer"),
-        respondToPreflight: vi.fn(async () => true),
-        processMessageFn: vi.fn(async function* () {
-            yield { type: "content", content: "ok" };
-        }),
-        detectVerifyRecipe: vi.fn(async () => ({ testCommands: ["npm test"], coverage: 80, shellInitCommands: [] })),
-        // mode="new" bypasses Mode C auto-detection so runHotPath / runStart are exercised
-        // (Mode C would dispatch to runMaintain and emit path="maintain" instead).
-        mode: "new",
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("route-decision emit — runHotPath (path=hot-path)", () => {
-    let emitEvent;
-    beforeEach(() => {
-        emitEvent = vi.fn();
-        globalThis.__muonroiAgentRuntime = { emitEvent };
-        vi.clearAllMocks();
-        emitEvent.mockClear();
-        process.env.MUONROI_PHASE_MODE = "0";
-        // biome-ignore lint/correctness/useYield: intentional mock generator
-        runSprint.mockImplementation(async function* () {
-            return shippedIter(1);
-        });
-    });
-    afterEach(() => {
-        delete globalThis.__muonroiAgentRuntime;
-        delete process.env.MUONROI_PHASE_MODE;
-    });
-    it("emits route-decision with path=hot-path for complexity=low", async () => {
-        const flowDir = await tmpFlowDir();
-        await drain(runProductLoop(makeOpts(flowDir, { complexity: "low" })));
-        const routeDecisions = emitEvent.mock.calls
-            .map((call) => call[0])
-            .filter((e) => e.kind === "route-decision");
-        expect(routeDecisions.length).toBeGreaterThanOrEqual(1);
-        expect(routeDecisions[0].path).toBe("hot-path");
-        expect(routeDecisions[0].forceCouncil).toBe(false);
-        expect(routeDecisions[0].t).toBe("event");
-        expect(typeof routeDecisions[0].runId).toBe("string");
-        expect(routeDecisions[0].runId).not.toBe("");
-    });
-});
-describe("route-decision emit — runStart (path=council)", () => {
-    let emitEvent;
-    beforeEach(() => {
-        emitEvent = vi.fn();
-        globalThis.__muonroiAgentRuntime = { emitEvent };
-        vi.clearAllMocks();
-        emitEvent.mockClear();
-        process.env.MUONROI_PHASE_MODE = "0";
-        // Mock the loop-driver to yield done immediately so runStart completes
-        runLoopDriver.mockImplementation(async function* () {
-            yield { type: "content", content: "running" };
-            return { success: true, stage: "shipped", sprintsRun: 1, shipped: true };
-        });
-    });
-    afterEach(() => {
-        delete globalThis.__muonroiAgentRuntime;
-        delete process.env.MUONROI_PHASE_MODE;
-    });
-    it("emits route-decision with path=council for complexity=high", async () => {
-        const flowDir = await tmpFlowDir();
-        await drain(runProductLoop(makeOpts(flowDir, { complexity: "high" })));
-        const routeDecisions = emitEvent.mock.calls
-            .map((call) => call[0])
-            .filter((e) => e.kind === "route-decision");
-        expect(routeDecisions.length).toBeGreaterThanOrEqual(1);
-        expect(routeDecisions[0].path).toBe("council");
-        expect(routeDecisions[0].t).toBe("event");
-    });
-    it("emits route-decision with path=council when forceCouncil=true (complexity=low)", async () => {
-        const flowDir = await tmpFlowDir();
-        await drain(runProductLoop(makeOpts(flowDir, {
-            complexity: "low",
-            flags: { maxCost: 50, maxSprints: 8, doneThreshold: 0.9, forceCouncil: true },
-        })));
-        const routeDecisions = emitEvent.mock.calls
-            .map((call) => call[0])
-            .filter((e) => e.kind === "route-decision");
-        expect(routeDecisions.length).toBeGreaterThanOrEqual(1);
-        expect(routeDecisions[0].path).toBe("council");
-        expect(routeDecisions[0].forceCouncil).toBe(true);
-    });
-});
-describe("route-decision emit — zero overhead when agentRuntime unset", () => {
-    beforeEach(() => {
-        globalThis.__muonroiAgentRuntime = undefined;
-        vi.clearAllMocks();
-        process.env.MUONROI_PHASE_MODE = "0";
-        // biome-ignore lint/correctness/useYield: intentional mock generator
-        runSprint.mockImplementation(async function* () {
-            return shippedIter(1);
-        });
-    });
-    afterEach(() => {
-        delete globalThis.__muonroiAgentRuntime;
-        delete process.env.MUONROI_PHASE_MODE;
-    });
-    it("runProductLoop (hot-path) completes without throwing when no agentRuntime", async () => {
-        const flowDir = await tmpFlowDir();
-        await expect(drain(runProductLoop(makeOpts(flowDir, { complexity: "low" })))).resolves.toBeDefined();
-    });
-});
-//# sourceMappingURL=route-decision-emit.test.js.map

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

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

package/dist/src/product-loop/__tests__/seed-questions.test.js

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SEED_DIMENSIONS } from "../seed-questions.js";
-describe("SEED_DIMENSIONS", () => {
-    it("has exactly 6 dimensions", () => {
-        expect(SEED_DIMENSIONS.length).toBe(6);
-    });
-    it("has all required IDs in order", () => {
-        const ids = SEED_DIMENSIONS.map((d) => d.id);
-        expect(ids).toEqual([
-            "persona",
-            "core-features",
-            "non-functional",
-            "tech-constraints",
-            "success-metric",
-            "cost-tolerance",
-        ]);
-    });
-    it("has required flag set to true for all", () => {
-        SEED_DIMENSIONS.forEach((d) => {
-            expect(d.isRequired).toBe(true);
-        });
-    });
-    it("has non-empty question text ending with ?", () => {
-        SEED_DIMENSIONS.forEach((d) => {
-            expect(d.question).toMatch(/\?$/);
-            expect(d.question.length).toBeGreaterThan(10);
-        });
-    });
-});
-//# sourceMappingURL=seed-questions.test.js.map

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

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

package/dist/src/product-loop/__tests__/ship-polish.test.js

@@ -1,96 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { polishDelivery } from "../ship-polish.js";
-function makeSpec(overrides = {}) {
-    return {
-        idea: "Build a CLI that summarizes git logs",
-        persona: "open-source maintainers",
-        mvp: ["parse log", "render summary"],
-        phase2: ["AI auto-categorization"],
-        architecture: "single-binary Node CLI; pure stdout",
-        ioContract: "stdin: git log --oneline\nstdout: markdown summary",
-        folderStructure: "src/, bin/, tests/",
-        sprintEstimate: 3,
-        costEstimate: 2,
-        createdAt: new Date(),
-        ...overrides,
-    };
-}
-async function makeTmp() {
-    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), "ship-cwd-"));
-    const runDir = await fs.mkdtemp(path.join(os.tmpdir(), "ship-run-"));
-    return { cwd, runDir };
-}
-describe("polishDelivery", () => {
-    const cleanups = [];
-    afterEach(async () => {
-        for (const c of cleanups) {
-            await fs.rm(c, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-        }
-        cleanups.length = 0;
-    });
-    it("writes README from spec when none exists", async () => {
-        const { cwd, runDir } = await makeTmp();
-        cleanups.push(cwd, runDir);
-        const r = await polishDelivery({ cwd, runDir, productSpec: makeSpec(), runId: "r1" });
-        expect(r.readmeWritten).toBe(true);
-        const readme = await fs.readFile(path.join(cwd, "README.md"), "utf-8");
-        expect(readme).toContain("# Build a CLI that summarizes git logs");
-        expect(readme).toContain("## Audience");
-        expect(readme).toContain("- parse log");
-        expect(readme).toContain("## Architecture");
-        expect(readme).toMatch(/scaffolded/i);
-    });
-    it("preserves existing README", async () => {
-        const { cwd, runDir } = await makeTmp();
-        cleanups.push(cwd, runDir);
-        await fs.writeFile(path.join(cwd, "README.md"), "# Existing\n", "utf-8");
-        const r = await polishDelivery({ cwd, runDir, productSpec: makeSpec(), runId: "r2" });
-        expect(r.readmeWritten).toBe(false);
-        expect(r.preserved).toContain("README.md");
-        const readme = await fs.readFile(path.join(cwd, "README.md"), "utf-8");
-        expect(readme.trim()).toBe("# Existing");
-    });
-    it("fills missing package.json fields without overwriting present ones", async () => {
-        const { cwd, runDir } = await makeTmp();
-        cleanups.push(cwd, runDir);
-        await fs.writeFile(path.join(cwd, "package.json"), JSON.stringify({ version: "1.2.3", scripts: { build: "tsc" } }, null, 2), "utf-8");
-        const r = await polishDelivery({ cwd, runDir, productSpec: makeSpec(), runId: "r3" });
-        expect(r.packageJsonUpdated).toBe(true);
-        const pkg = JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8"));
-        // existing fields preserved
-        expect(pkg.version).toBe("1.2.3");
-        expect(pkg.scripts.build).toBe("tsc");
-        // missing fields filled
-        expect(pkg.name).toBeTruthy();
-        expect(pkg.description).toContain("git logs");
-    });
-    it("leaves a fully-populated package.json alone", async () => {
-        const { cwd, runDir } = await makeTmp();
-        cleanups.push(cwd, runDir);
-        const original = { name: "fixed", version: "2.0.0", description: "stay" };
-        await fs.writeFile(path.join(cwd, "package.json"), `${JSON.stringify(original, null, 2)}\n`, "utf-8");
-        const r = await polishDelivery({ cwd, runDir, productSpec: makeSpec(), runId: "r4" });
-        expect(r.packageJsonUpdated).toBe(false);
-        const pkg = JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8"));
-        expect(pkg).toEqual(original);
-    });
-    it("skips silently when there is no package.json", async () => {
-        const { cwd, runDir } = await makeTmp();
-        cleanups.push(cwd, runDir);
-        const r = await polishDelivery({ cwd, runDir, productSpec: makeSpec(), runId: "r5" });
-        expect(r.packageJsonUpdated).toBe(false);
-        // no package.json should be created
-        await expect(fs.access(path.join(cwd, "package.json"))).rejects.toBeTruthy();
-    });
-    it("always writes delivery-notes.md to runDir", async () => {
-        const { cwd, runDir } = await makeTmp();
-        cleanups.push(cwd, runDir);
-        await polishDelivery({ cwd, runDir, productSpec: makeSpec(), runId: "r6" });
-        const notes = await fs.readFile(path.join(runDir, "delivery-notes.md"), "utf-8");
-        expect(notes).toContain("Delivery");
-    });
-});
-//# sourceMappingURL=ship-polish.test.js.map

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

@@ -1,6 +0,0 @@
-/**
- * src/product-loop/__tests__/sprint-planner.test.ts
- *
- * Unit tests for sprint-planner.ts.
- */
-export {};