muonroi-cli 1.8.1 → 1.8.3

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

@@ -1,414 +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 { appendCustomerDecision, clearAwaitingCustomerReview, clearRetroPending, collectStuckPhases, markAwaitingCustomerReview, markPhaseStatus, markRetroPending, readLastActivity, readPhaseStatus, runPhases, updateLastActivity, } from "../phase-runner.js";
-describe("phase-runner markers (subsystem E)", () => {
-    let flowDir;
-    const runId = "r1";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `runner-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    });
-    it("markPhaseStatus writes and reads back", async () => {
-        await markPhaseStatus(flowDir, runId, "phase-1", "in-progress");
-        expect(await readPhaseStatus(flowDir, runId, "phase-1")).toBe("in-progress");
-        await markPhaseStatus(flowDir, runId, "phase-1", "done");
-        expect(await readPhaseStatus(flowDir, runId, "phase-1")).toBe("done");
-    });
-    it("awaiting-customer-review marker round-trip", async () => {
-        await markAwaitingCustomerReview(flowDir, runId, "phase-1", 1);
-        const { readArtifact } = await import("../../flow/artifact-io.js");
-        const map = await readArtifact(path.join(flowDir, "runs", runId), "state.md");
-        expect(map?.sections.get("awaiting-customer-review:phase-1:sprint-1")).toBeDefined();
-        await clearAwaitingCustomerReview(flowDir, runId, "phase-1", 1);
-        const map2 = await readArtifact(path.join(flowDir, "runs", runId), "state.md");
-        expect(map2?.sections.get("awaiting-customer-review:phase-1:sprint-1")).toBeUndefined();
-    });
-    it("retro-pending marker round-trip", async () => {
-        await markRetroPending(flowDir, runId, "phase-1", 1);
-        const { readArtifact } = await import("../../flow/artifact-io.js");
-        const map = await readArtifact(path.join(flowDir, "runs", runId), "state.md");
-        expect(map?.sections.get("retro-pending:phase-1:sprint-1")).toBeDefined();
-        await clearRetroPending(flowDir, runId, "phase-1", 1);
-        const map2 = await readArtifact(path.join(flowDir, "runs", runId), "state.md");
-        expect(map2?.sections.get("retro-pending:phase-1:sprint-1")).toBeUndefined();
-    });
-    it("appendCustomerDecision uses monotonic seq", async () => {
-        await appendCustomerDecision(flowDir, runId, {
-            phaseId: "phase-1",
-            sprintN: 1,
-            verdict: "accept",
-        });
-        await appendCustomerDecision(flowDir, runId, {
-            phaseId: "phase-1",
-            sprintN: 2,
-            verdict: "reject",
-            feedback: "needs work",
-        });
-        const { readArtifact } = await import("../../flow/artifact-io.js");
-        const map = await readArtifact(path.join(flowDir, "runs", runId), "state.md");
-        const raw = map?.sections.get("Customer Decisions");
-        expect(raw).toBeDefined();
-        const parsed = JSON.parse(raw);
-        expect(parsed.items).toHaveLength(2);
-        expect(parsed.items[0].seq).toBe(1);
-        expect(parsed.items[1].seq).toBe(2);
-        expect(parsed.items[1].feedback).toBe("needs work");
-    });
-    it("updateLastActivity + readLastActivity round-trip", async () => {
-        await updateLastActivity(flowDir, runId);
-        const got = await readLastActivity(flowDir, runId);
-        expect(got).toBeTruthy();
-        expect(new Date(got).getTime()).toBeLessThanOrEqual(Date.now());
-    });
-    it("collectStuckPhases returns blocked + pending IDs", async () => {
-        await markPhaseStatus(flowDir, runId, "phase-1", "done");
-        await markPhaseStatus(flowDir, runId, "phase-2", "blocked");
-        await markPhaseStatus(flowDir, runId, "phase-3", "pending");
-        const stuck = await collectStuckPhases(flowDir, runId);
-        expect(stuck.sort()).toEqual(["phase-2", "phase-3"]);
-    });
-});
-describe("runPhases orchestrator (subsystem E)", () => {
-    let flowDir;
-    const runId = "r-orch";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `orch-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    });
-    // biome-ignore lint/suspicious/noExplicitAny: test helper accepts partial overrides for ease
-    function baseArgs(over = {}) {
-        return {
-            flowDir,
-            runId,
-            manifest: { idea: "X", capUsd: 10, maxSprints: 6, doneThreshold: 0.8, createdAt: new Date() },
-            clarifiedSpec: { problemStatement: "p", constraints: [], successCriteria: ["A", "B"], scope: "s", rawQA: [] },
-            projectContext: { context: {}, prefillSource: {}, version: 1 },
-            leader: {
-                generate: vi.fn().mockResolvedValue({
-                    content: JSON.stringify({
-                        version: 1,
-                        generatedAt: "2026-05-13T00:00:00Z",
-                        phases: [
-                            {
-                                id: "phase-1",
-                                name: "n",
-                                goal: "g",
-                                successCriteria: ["A"],
-                                scope: "s",
-                                exitCondition: { type: "criteria-threshold", min: 0.8 },
-                                dependsOn: [],
-                                maxSprints: 1,
-                            },
-                            {
-                                id: "phase-2",
-                                name: "n",
-                                goal: "g",
-                                successCriteria: ["B"],
-                                scope: "s",
-                                exitCondition: { type: "criteria-threshold", min: 0.8 },
-                                dependsOn: ["phase-1"],
-                                maxSprints: 1,
-                            },
-                        ],
-                    }),
-                    costUsd: 0.1,
-                }),
-            },
-            leaderModelId: "m1",
-            capUsd: 10,
-            remainingUsd: async () => 5,
-            awaitCustomerVerdict: async (_args) => ({ verdict: "accept" }),
-            suppressPush: true,
-            backoffDelays: [1, 1, 1],
-            sprintRunner: vi.fn(async function* () {
-                yield { type: "info", content: "" };
-                return { scoreBefore: 0.0, scoreAfter: 0.9, criteriaMet: 1, totalCriteria: 1 };
-            }),
-            ...over,
-        };
-    }
-    it("iterates phases in DAG order, returns product verdict", async () => {
-        const args = baseArgs();
-        // biome-ignore lint/suspicious/noExplicitAny: intentional cast for test stub typing
-        const gen = runPhases(args);
-        let res;
-        while (true) {
-            const n = await gen.next();
-            if (n.done) {
-                res = n.value;
-                break;
-            }
-        }
-        expect(args.sprintRunner).toHaveBeenCalledTimes(2);
-        expect(res?.pass).toBe(true);
-    });
-    it("skips done phases on resume", async () => {
-        const args = baseArgs();
-        await markPhaseStatus(flowDir, runId, "phase-1", "done");
-        const { writePhasePlan } = await import("../phase-plan.js");
-        await writePhasePlan(flowDir, runId, {
-            version: 1,
-            generatedAt: "t",
-            phases: [
-                {
-                    id: "phase-1",
-                    name: "n",
-                    goal: "g",
-                    successCriteria: ["A"],
-                    scope: "s",
-                    exitCondition: { type: "criteria-threshold", min: 0.8 },
-                    dependsOn: [],
-                    maxSprints: 1,
-                },
-                {
-                    id: "phase-2",
-                    name: "n",
-                    goal: "g",
-                    successCriteria: ["B"],
-                    scope: "s",
-                    exitCondition: { type: "criteria-threshold", min: 0.8 },
-                    dependsOn: ["phase-1"],
-                    maxSprints: 1,
-                },
-            ],
-        });
-        // biome-ignore lint/suspicious/noExplicitAny: intentional cast for test stub typing
-        const gen = runPhases(args);
-        while (true) {
-            const n = await gen.next();
-            if (n.done)
-                break;
-        }
-        expect(args.sprintRunner).toHaveBeenCalledTimes(1);
-    });
-    it("customer abort → returns immediately with user-aborted reason", async () => {
-        const args = baseArgs({ awaitCustomerVerdict: async (_args) => ({ verdict: "abort" }) });
-        // biome-ignore lint/suspicious/noExplicitAny: intentional cast for test stub typing
-        const gen = runPhases(args);
-        let res;
-        while (true) {
-            const n = await gen.next();
-            if (n.done) {
-                res = n.value;
-                break;
-            }
-        }
-        expect(res?.pass).toBe(false);
-        expect(res?.reason).toBe("user-aborted");
-    });
-    it("customer reject feedback persisted verbatim", async () => {
-        const args = baseArgs({
-            awaitCustomerVerdict: async (_args) => ({ verdict: "reject", feedback: "needs more polish" }),
-        });
-        // biome-ignore lint/suspicious/noExplicitAny: intentional cast for test stub typing
-        const gen = runPhases(args);
-        let count = 0;
-        while (true) {
-            const n = await gen.next();
-            if (n.done || count++ > 5)
-                break;
-        }
-        const { readArtifact } = await import("../../flow/artifact-io.js");
-        const map = await readArtifact(path.join(flowDir, "runs", runId), "state.md");
-        const cd = JSON.parse(map.sections.get("Customer Decisions"));
-        expect(cd.items.some((d) => d.feedback?.includes("needs more polish"))).toBe(true);
-    });
-    it("phase deadlock when phase-2 blocked because phase-1 never completed", async () => {
-        const args = baseArgs({
-            sprintRunner: vi.fn(async function* () {
-                yield { type: "info", content: "" };
-                return { scoreBefore: 0.0, scoreAfter: 0.1, criteriaMet: 0, totalCriteria: 1 };
-            }),
-        });
-        await markPhaseStatus(flowDir, runId, "phase-1", "blocked");
-        const { writePhasePlan } = await import("../phase-plan.js");
-        await writePhasePlan(flowDir, runId, {
-            version: 1,
-            generatedAt: "t",
-            phases: [
-                {
-                    id: "phase-1",
-                    name: "n",
-                    goal: "g",
-                    successCriteria: ["A"],
-                    scope: "s",
-                    exitCondition: { type: "criteria-threshold", min: 0.8 },
-                    dependsOn: [],
-                    maxSprints: 1,
-                },
-                {
-                    id: "phase-2",
-                    name: "n",
-                    goal: "g",
-                    successCriteria: ["B"],
-                    scope: "s",
-                    exitCondition: { type: "criteria-threshold", min: 0.8 },
-                    dependsOn: ["phase-1"],
-                    maxSprints: 1,
-                },
-            ],
-        });
-        // biome-ignore lint/suspicious/noExplicitAny: intentional cast for test stub typing
-        const gen = runPhases(args);
-        let res;
-        while (true) {
-            const n = await gen.next();
-            if (n.done) {
-                res = n.value;
-                break;
-            }
-        }
-        expect(res?.pass).toBe(false);
-        expect(res?.reason).toMatch(/phases-deadlocked/);
-    });
-});
-describe("resume protocol (subsystem E)", () => {
-    let flowDir;
-    const runId = "r-res";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `res-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    });
-    // biome-ignore lint/suspicious/noExplicitAny: test helper accepts partial overrides for ease
-    function baseArgs(over = {}) {
-        return {
-            flowDir,
-            runId,
-            manifest: { idea: "X", capUsd: 10, maxSprints: 6, doneThreshold: 0.8, createdAt: new Date() },
-            clarifiedSpec: { problemStatement: "p", constraints: [], successCriteria: ["A", "B"], scope: "s", rawQA: [] },
-            projectContext: { context: {}, prefillSource: {}, version: 1 },
-            leader: { generate: vi.fn().mockResolvedValue({ content: "fallback", costUsd: 0 }) },
-            leaderModelId: "m1",
-            capUsd: 10,
-            remainingUsd: async () => 5,
-            awaitCustomerVerdict: async (_args) => ({ verdict: "accept" }),
-            suppressPush: true,
-            backoffDelays: [1, 1, 1],
-            sprintRunner: vi.fn(async function* () {
-                yield { type: "info", content: "" };
-                return { scoreBefore: 0.5, scoreAfter: 0.9, criteriaMet: 1, totalCriteria: 1 };
-            }),
-            ...over,
-        };
-    }
-    it("resume with retro-pending marker replays retro for sprint", async () => {
-        const { writePhasePlan } = await import("../phase-plan.js");
-        await writePhasePlan(flowDir, runId, {
-            version: 1,
-            generatedAt: "t",
-            phases: [
-                {
-                    id: "phase-1",
-                    name: "n",
-                    goal: "g",
-                    successCriteria: ["A", "B"],
-                    scope: "s",
-                    exitCondition: { type: "criteria-threshold", min: 0.8 },
-                    dependsOn: [],
-                    maxSprints: 1,
-                },
-            ],
-        });
-        await markRetroPending(flowDir, runId, "phase-1", 1);
-        await appendCustomerDecision(flowDir, runId, { phaseId: "phase-1", sprintN: 1, verdict: "accept" });
-        await markPhaseStatus(flowDir, runId, "phase-1", "in-progress");
-        const retroContent = JSON.stringify({ wentWell: ["w"], toImprove: ["i"], nextSprintFocus: "focus" });
-        const args2 = {
-            ...baseArgs(),
-            leader: { generate: vi.fn().mockResolvedValue({ content: retroContent, costUsd: 0.05 }) },
-        };
-        // biome-ignore lint/suspicious/noExplicitAny: intentional cast for test stub typing
-        const gen = (await import("../phase-runner.js")).runPhases(args2);
-        while (true) {
-            const n = await gen.next();
-            if (n.done)
-                break;
-        }
-        const { readArtifact } = await import("../../flow/artifact-io.js");
-        const map = await readArtifact(path.join(flowDir, "runs", runId), "state.md");
-        expect(map?.sections.has("retro-pending:phase-1:sprint-1")).toBe(false);
-    });
-    it("resume with plan corruption regenerates plan", async () => {
-        const phasesPath = path.join(flowDir, "runs", runId, "phases.md");
-        await fs.writeFile(phasesPath, "## Plan\n\n{not json\n");
-        const goodPlan = {
-            version: 1,
-            generatedAt: "t",
-            phases: [
-                {
-                    id: "phase-1",
-                    name: "n",
-                    goal: "g",
-                    successCriteria: ["A", "B"],
-                    scope: "s",
-                    exitCondition: { type: "criteria-threshold", min: 0.8 },
-                    dependsOn: [],
-                    maxSprints: 1,
-                },
-            ],
-        };
-        const args2 = {
-            ...baseArgs(),
-            leader: { generate: vi.fn().mockResolvedValue({ content: JSON.stringify(goodPlan), costUsd: 0.1 }) },
-        };
-        // biome-ignore lint/suspicious/noExplicitAny: intentional cast for test stub typing
-        const gen = (await import("../phase-runner.js")).runPhases(args2);
-        while (true) {
-            const n = await gen.next();
-            if (n.done)
-                break;
-        }
-        const entries = await fs.readdir(path.join(flowDir, "runs", runId));
-        expect(entries.some((e) => e.startsWith("phases.md.corrupt-"))).toBe(true);
-    });
-});
-describe("phase-runner coverage gaps (subsystem E)", () => {
-    let flowDir;
-    const runId = "r-gaps";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `gaps-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    });
-    it("markPhaseStatus no-op when same status", async () => {
-        await markPhaseStatus(flowDir, runId, "phase-1", "done");
-        const before = await import("../../flow/artifact-io.js").then((m) => m.readArtifact(path.join(flowDir, "runs", runId), "state.md"));
-        // calling with same status should be a no-op (no write)
-        await markPhaseStatus(flowDir, runId, "phase-1", "done");
-        const after = await import("../../flow/artifact-io.js").then((m) => m.readArtifact(path.join(flowDir, "runs", runId), "state.md"));
-        expect(JSON.parse(after.sections.get("Phase Plan State")).phasesStatus["phase-1"]).toBe("done");
-        // lastActivityUtc should NOT change on no-op (same content)
-        expect(before?.sections.get("Phase Plan State")).toBe(after?.sections.get("Phase Plan State"));
-    });
-    it("clearAwaitingCustomerReview on missing state.md is a no-op", async () => {
-        // file does not exist — should return without throwing
-        await expect(clearAwaitingCustomerReview(flowDir, runId, "phase-1", 1)).resolves.toBeUndefined();
-    });
-    it("clearRetroPending on missing state.md is a no-op", async () => {
-        await expect(clearRetroPending(flowDir, runId, "phase-1", 1)).resolves.toBeUndefined();
-    });
-});
-describe("customer decision feedback truncation (subsystem E)", () => {
-    let flowDirFb;
-    const runIdFb = "r-fb";
-    beforeEach(async () => {
-        flowDirFb = path.join(os.tmpdir(), `fb-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDirFb, "runs", runIdFb), { recursive: true });
-    });
-    it("feedback > 2000 chars is truncated with marker", async () => {
-        const long = "X".repeat(3000);
-        await appendCustomerDecision(flowDirFb, runIdFb, {
-            phaseId: "phase-1",
-            sprintN: 1,
-            verdict: "reject",
-            feedback: long,
-        });
-        const { readArtifact } = await import("../../flow/artifact-io.js");
-        const map = await readArtifact(path.join(flowDirFb, "runs", runIdFb), "state.md");
-        const items = JSON.parse(map.sections.get("Customer Decisions")).items;
-        expect(items[0].feedback.length).toBeLessThanOrEqual(2100);
-        expect(items[0].feedback).toContain("feedback truncated");
-    });
-});
-//# sourceMappingURL=phase-runner.test.js.map

package/dist/src/product-loop/__tests__/phase-tracker-bridge.test.d.ts

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

package/dist/src/product-loop/__tests__/phase-tracker-bridge.test.js

@@ -1,67 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import * as phaseOutcome from "../../ee/phase-outcome.js";
-import * as phaseTracker from "../../ee/phase-tracker.js";
-import { postSprintBoundary } from "../phase-tracker-bridge.js";
-vi.mock("../../ee/phase-outcome.js", () => ({
-    fireAndForgetPhaseOutcome: vi.fn(),
-}));
-vi.mock("../../ee/phase-tracker.js", { spy: true });
-describe("phase-tracker-bridge", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        phaseTracker.resetPhaseTracker();
-    });
-    it("posts outcome when transitioning from sprint 1 to sprint 2", async () => {
-        const sessionId = "test-session";
-        // Setup: already in sprint-1
-        phaseTracker.setPhase("sprint-1");
-        await postSprintBoundary({
-            sessionId,
-            sprintN: 2,
-            outcome: "pass",
-            evidence: { some: "data" },
-        });
-        // Should have called setPhase with sprint-2
-        expect(phaseTracker.setPhase).toHaveBeenCalledWith("sprint-2");
-        // Should have fired outcome for sprint-1 (the drained one)
-        expect(phaseOutcome.fireAndForgetPhaseOutcome).toHaveBeenCalledWith(expect.objectContaining({
-            sessionId,
-            phaseName: "sprint-1",
-            outcome: "pass",
-            evidence: expect.objectContaining({ some: "data" }),
-        }), {});
-    });
-    it('posts "aborted" outcome', async () => {
-        const sessionId = "test-session";
-        phaseTracker.setPhase("sprint-1");
-        await postSprintBoundary({
-            sessionId,
-            sprintN: 1, // End current sprint
-            outcome: "aborted",
-            evidence: { reason: "user cancelled" },
-        });
-        // Ending the same phase doesn't return a snapshot via setPhase normally
-        // but the bridge should handle explicit termination if we want to post an outcome
-        // for the CURRENT sprint.
-        // Actually, the plan says:
-        // "Calls phaseTracker.setPhase(`sprint-${sprintN}`) — RESEARCH §2 confirmed this is the boundary trigger"
-        // "Calls fireAndForgetPhaseOutcome with the snapshot returned by setPhase (when boundary crossed)"
-        // If sprintN is the same, setPhase returns null.
-        // Wait, RESEARCH §2 says "boundary trigger is setPhase, not iterations.md append".
-        // If we are at the end of sprint 1, we call postSprintBoundary with outcome for sprint 1.
-        // To get the snapshot for sprint 1, we must call setPhase with something else (e.g. 'sprint-2') OR endPhase().
-    });
-    it("no-op when setPhase returns null (same phase)", async () => {
-        const sessionId = "test-session";
-        phaseTracker.setPhase("sprint-1");
-        vi.clearAllMocks();
-        await postSprintBoundary({
-            sessionId,
-            sprintN: 1,
-            outcome: "pass",
-        });
-        expect(phaseTracker.setPhase).toHaveBeenCalledWith("sprint-1");
-        expect(phaseOutcome.fireAndForgetPhaseOutcome).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=phase-tracker-bridge.test.js.map

package/dist/src/product-loop/__tests__/pick-backend-stack.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * Unit tests for pickBackendStackFromDetection — the rule that decides
- * whether detection signals are strong enough to skip the backendStack
- * interview question (returning a synthesized answer) vs ambiguous enough
- * that we should ask the user.
- *
- * Original implementation just took `languages[0]` which was arbitrary
- * for polyglot repos (TS + Python → "TypeScript" wins by alphabetical
- * walk order, never asking the user about the actual change target).
- */
-export {};

package/dist/src/product-loop/__tests__/pick-backend-stack.test.js

@@ -1,95 +0,0 @@
-/**
- * Unit tests for pickBackendStackFromDetection — the rule that decides
- * whether detection signals are strong enough to skip the backendStack
- * interview question (returning a synthesized answer) vs ambiguous enough
- * that we should ask the user.
- *
- * Original implementation just took `languages[0]` which was arbitrary
- * for polyglot repos (TS + Python → "TypeScript" wins by alphabetical
- * walk order, never asking the user about the actual change target).
- */
-import { describe, expect, it } from "vitest";
-import { pickBackendStackFromDetection } from "../gather.js";
-function manifest(over = {}) {
-    return {
-        file: "package.json",
-        type: "package.json",
-        weight: 1,
-        inferredLang: "TypeScript",
-        inferredFrameworks: [],
-        ...over,
-    };
-}
-function detection(over = {}) {
-    return {
-        isGitRepo: true,
-        hasCommitHistory: true,
-        srcFileCount: 50,
-        manifests: [],
-        languages: [],
-        frameworks: [],
-        classification: "existing",
-        ...over,
-    };
-}
-describe("pickBackendStackFromDetection", () => {
-    it("existing + single manifest → uses manifest.inferredLang + first framework", () => {
-        const out = pickBackendStackFromDetection(detection({
-            manifests: [manifest({ inferredLang: "TypeScript", inferredFrameworks: ["react", "vite"] })],
-            languages: ["TypeScript"],
-            frameworks: ["react", "vite"],
-        }));
-        expect(out).toEqual({ language: "TypeScript", framework: "react" });
-    });
-    it("existing + single manifest with no frameworks → renders (none detected)", () => {
-        const out = pickBackendStackFromDetection(detection({
-            manifests: [manifest({ inferredLang: "Rust", inferredFrameworks: [] })],
-            languages: ["Rust"],
-        }));
-        expect(out).toEqual({ language: "Rust", framework: "(none detected)" });
-    });
-    it("ambiguous + exactly one language → uses it, no framework", () => {
-        const out = pickBackendStackFromDetection(detection({
-            classification: "ambiguous",
-            manifests: [],
-            languages: ["Go"],
-        }));
-        expect(out).toEqual({ language: "Go", framework: "(none detected)" });
-    });
-    it("ambiguous + polyglot (regression — was picking [0] arbitrarily) → returns null", () => {
-        const out = pickBackendStackFromDetection(detection({
-            classification: "ambiguous",
-            manifests: [
-                manifest({ inferredLang: "TypeScript" }),
-                manifest({ file: "pyproject.toml", type: "pyproject.toml", inferredLang: "Python" }),
-            ],
-            languages: ["TypeScript", "Python"],
-        }));
-        expect(out).toBeNull();
-    });
-    it("ambiguous + zero languages → returns null", () => {
-        const out = pickBackendStackFromDetection(detection({ classification: "ambiguous", manifests: [], languages: [] }));
-        expect(out).toBeNull();
-    });
-    it("existing + multiple manifests should never happen (classify forces ambiguous) but is null-safe", () => {
-        // Defensive: classify() would mark this ambiguous, but if a future caller
-        // ever passes "existing" with multiple manifests, pick should NOT crash —
-        // it should bail out cleanly.
-        const out = pickBackendStackFromDetection(detection({
-            classification: "existing",
-            manifests: [manifest(), manifest({ file: "Cargo.toml", type: "Cargo.toml", inferredLang: "Rust" })],
-            languages: ["TypeScript", "Rust"],
-        }));
-        expect(out).toBeNull();
-    });
-    it("greenfield → returns null (no signal to use)", () => {
-        const out = pickBackendStackFromDetection(detection({
-            classification: "greenfield",
-            manifests: [],
-            languages: [],
-            srcFileCount: 0,
-        }));
-        expect(out).toBeNull();
-    });
-});
-//# sourceMappingURL=pick-backend-stack.test.js.map

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

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

package/dist/src/product-loop/__tests__/product-identity.test.js

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { productSlug } from "../product-identity.js";
-describe("productSlug", () => {
-    it("returns 8-char hash prefix + dash + slug suffix", () => {
-        const out = productSlug("Blog platform with auth");
-        expect(out).toMatch(/^[a-f0-9]{8}-[a-z0-9-]+$/);
-    });
-    it("stable: same input → same output", () => {
-        const a = productSlug("Build a chat app");
-        const b = productSlug("Build a chat app");
-        expect(a).toBe(b);
-    });
-    it("different inputs produce different slugs", () => {
-        expect(productSlug("idea A")).not.toBe(productSlug("idea B"));
-    });
-    it("total length ≤ 49 chars (8 + 1 + 40)", () => {
-        const out = productSlug("a".repeat(500));
-        expect(out.length).toBeLessThanOrEqual(49);
-    });
-    it("slug suffix only contains [a-z0-9-]", () => {
-        const out = productSlug("HELLO!@# WORLD ñ");
-        const suffix = out.slice(9);
-        expect(/^[a-z0-9-]*$/.test(suffix)).toBe(true);
-    });
-    it("whitespace-only idea still yields valid slug", () => {
-        const out = productSlug("   ");
-        expect(out).toMatch(/^[a-f0-9]{8}/);
-    });
-    it("Discord round-trip: name muonroi-${slug} survives Discord's lowercase+replace transform unchanged", () => {
-        const slug = productSlug("My Cool Product 2026");
-        const channelName = `muonroi-${slug}`;
-        const discordTransformed = channelName.toLowerCase().replace(/[^a-z0-9-_]/g, "-");
-        expect(channelName).toBe(discordTransformed);
-    });
-    it("Vietnamese with diacritics produces clean slug", () => {
-        const out = productSlug("Sản phẩm thử nghiệm");
-        expect(/^[a-f0-9]{8}-[a-z0-9-]+$/.test(out)).toBe(true);
-    });
-});
-//# sourceMappingURL=product-identity.test.js.map

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

@@ -1,8 +0,0 @@
-/**
- * src/product-loop/__tests__/progress-snapshot.test.ts
- *
- * Unit tests for computeProgressSnapshot() and renderSnapshotMarkdown().
- * Uses temp directories for backlog/sprint files. Mocks getDatabase so
- * no real SQLite DB is needed.
- */
-export {};