muonroi-cli 1.3.4 → 1.4.1

package/dist/src/product-loop/__tests__/maintenance-task-synthesis.test.js

@@ -0,0 +1,67 @@
+/**
+ * maintenance-task-synthesis.test.ts
+ *
+ * Heuristic synthesis used by runMaintain when no explicit task shape is given.
+ * Replaces the previous hardcoded `kind: "bug"` and single default criterion
+ * with idea-text-driven detection.
+ */
+import { describe, expect, it } from "vitest";
+import { buildDefaultAcceptanceCriteria, detectMaintenanceKind } from "../index.js";
+describe("detectMaintenanceKind", () => {
+    it("detects bug from 'fix' / 'bug' / 'crash' keywords", () => {
+        expect(detectMaintenanceKind("fix login crash on Safari")).toBe("bug");
+        expect(detectMaintenanceKind("bug: token expires too early")).toBe("bug");
+        expect(detectMaintenanceKind("auth flow is broken")).toBe("bug");
+        expect(detectMaintenanceKind("hotfix the rate limiter")).toBe("bug");
+    });
+    it("detects refactor from refactor/rename/cleanup keywords", () => {
+        expect(detectMaintenanceKind("refactor the auth module")).toBe("refactor");
+        expect(detectMaintenanceKind("rename UserService to AccountService")).toBe("refactor");
+        expect(detectMaintenanceKind("split the giant App.tsx file")).toBe("refactor");
+        expect(detectMaintenanceKind("extract validation into a hook")).toBe("refactor");
+    });
+    it("detects docs from documentation keywords", () => {
+        expect(detectMaintenanceKind("update the README")).toBe("docs");
+        expect(detectMaintenanceKind("add jsdoc to public exports")).toBe("docs");
+        expect(detectMaintenanceKind("write documentation for the API")).toBe("docs");
+    });
+    it("detects chore from upgrade/deps/lint keywords", () => {
+        expect(detectMaintenanceKind("bump react to 19")).toBe("chore");
+        expect(detectMaintenanceKind("upgrade dependencies")).toBe("chore");
+        expect(detectMaintenanceKind("fix lint errors")).toBe("bug"); // 'fix' wins — that's the user intent
+        expect(detectMaintenanceKind("run prettier across the repo")).toBe("feature"); // no keyword match → feature
+    });
+    it("falls back to feature for additive prompts", () => {
+        expect(detectMaintenanceKind("add a dark mode toggle")).toBe("feature");
+        expect(detectMaintenanceKind("implement OAuth login")).toBe("feature");
+        expect(detectMaintenanceKind("support CSV export")).toBe("feature");
+    });
+    it("bug keyword takes precedence over additive language", () => {
+        // 'fix' triggers bug even when prompt also says 'add'
+        expect(detectMaintenanceKind("fix the bug where adding items crashes")).toBe("bug");
+    });
+});
+describe("buildDefaultAcceptanceCriteria", () => {
+    it("always includes 'verify recipe passes'", () => {
+        const criteria = buildDefaultAcceptanceCriteria("anything goes");
+        expect(criteria[0]).toBe("Existing verify recipe passes after edits");
+    });
+    it("adds test-coverage criterion when idea mentions tests", () => {
+        const criteria = buildDefaultAcceptanceCriteria("add unit test for password hashing");
+        expect(criteria).toContain("New behavior is covered by at least one test");
+    });
+    it("adds no-regression criterion when idea hints at preservation", () => {
+        const criteria = buildDefaultAcceptanceCriteria("refactor without breaking existing API");
+        expect(criteria).toContain("No regression in existing test suite");
+    });
+    it("adds error-path criterion when idea mentions error/exception/null", () => {
+        const criteria = buildDefaultAcceptanceCriteria("crash when user input is null");
+        expect(criteria).toContain("Error path is handled explicitly (no silent swallowing)");
+    });
+    it("returns only the baseline for a neutral prompt", () => {
+        const criteria = buildDefaultAcceptanceCriteria("add a logout button");
+        expect(criteria).toHaveLength(1);
+        expect(criteria[0]).toBe("Existing verify recipe passes after edits");
+    });
+});
+//# sourceMappingURL=maintenance-task-synthesis.test.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * phase-a1-a3-sprint-runner.test.ts — Phase A unit tests (A1 + A3).
+ *
+ * A1: generate_plan no longer exits sprint-runner.
+ *     After council selects generate_plan, runSprint continues with
+ *     implementation → verification → judgment, emitting all 4 sprint_stage events.
+ *
+ * A3: sprint-runner emits phaseDone for implementation even when
+ *     processMessageFn throws (try/finally guard).
+ *
+ * These tests call runSprint directly (no mocking of sprint-runner.js itself).
+ */
+export {};

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

@@ -0,0 +1,268 @@
+/**
+ * phase-a1-a3-sprint-runner.test.ts — Phase A unit tests (A1 + A3).
+ *
+ * A1: generate_plan no longer exits sprint-runner.
+ *     After council selects generate_plan, runSprint continues with
+ *     implementation → verification → judgment, emitting all 4 sprint_stage events.
+ *
+ * A3: sprint-runner emits phaseDone for implementation even when
+ *     processMessageFn throws (try/finally guard).
+ *
+ * These tests call runSprint directly (no mocking of sprint-runner.js itself).
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// ── Top-level mocks (hoisted) ──────────────────────────────────────────────
+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(async () => undefined),
+    readCriteria: vi.fn(async () => []),
+    writeManifest: vi.fn(async () => undefined),
+    readManifest: vi.fn(async () => null),
+    markIterationCrashed: vi.fn(async () => undefined),
+    readIterations: 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"),
+}));
+vi.mock("../backlog-store.js", () => ({
+    readBacklog: vi.fn(async () => null),
+    writeBacklog: vi.fn(async () => undefined),
+}));
+vi.mock("../assumption-ledger.js", () => ({
+    readLedger: vi.fn(async () => null),
+    formatUnverifiedForSprintContext: vi.fn(() => ""),
+}));
+vi.mock("../discovery-persistence.js", () => ({
+    readProjectContext: vi.fn(async () => null),
+}));
+vi.mock("../progress-snapshot.js", () => ({
+    computeProgressSnapshot: vi.fn(async () => null),
+    renderSnapshotMarkdown: vi.fn(() => ""),
+}));
+vi.mock("../verify-failure-tracking.js", () => ({
+    loadVerifyFailureSignatures: vi.fn(async () => ({ signatures: [] })),
+    recordVerifyFailureAndMaybePush: vi.fn(async () => undefined),
+    computeFailureSignature: vi.fn(() => "sig"),
+    pushFailureToEE: vi.fn(async () => undefined),
+    saveVerifyFailureSignatures: vi.fn(async () => undefined),
+}));
+import { runCouncil } from "../../council/index.js";
+import { runVerifyOrchestration } from "../../verify/orchestrator.js";
+import { CB3_verifyBlank } from "../circuit-breakers.js";
+import { evaluateDoneGate } from "../done-gate.js";
+import { runSprint } from "../sprint-runner.js";
+const NO_ROLES = new Map();
+function 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 drainWithResult(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 };
+    }
+}
+// ── Common beforeEach ──────────────────────────────────────────────────────
+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: [] },
+    });
+});
+afterEach(() => {
+    delete globalThis.__muonroiAgentRuntime;
+});
+// ── A1: generate_plan stays within sprint-runner ───────────────────────────
+describe("A1: generate_plan no longer exits sprint-runner", () => {
+    it("after council returns synthesisText from generate_plan, sprint-runner emits all 4 phase events", async () => {
+        const processMessageFn = vi.fn(async function* () {
+            yield { type: "content", content: "implementing..." };
+        });
+        runCouncil.mockImplementation(async function* () {
+            yield { type: "content", content: "council planning..." };
+            // Simulate council returning synthesisText from generate_plan
+            return "Sprint plan locked (3 steps):\n- [high] Setup auth\n- [high] Build API\n- [medium] Tests";
+        });
+        const ctx = {
+            runId: "run-a1-test",
+            flowDir: "/tmp/flow-a1",
+            cwd: "/tmp/cwd-a1",
+            idea: "test idea",
+            sessionModelId: "test-model",
+            llm: {
+                generate: vi.fn(async () => "synthesis"),
+                research: vi.fn(async () => "research"),
+            },
+            flags: { maxCost: 100, maxSprints: 5, doneThreshold: 0.9 },
+            respondToQuestion: vi.fn(),
+            respondToPreflight: vi.fn(),
+            processMessageFn,
+            detectVerifyRecipe: vi.fn(async () => ({
+                testCommands: ["npm test"],
+                coverage: 80,
+                shellInitCommands: [],
+            })),
+        };
+        const { chunks } = await drainWithResult(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
+        // All 4 sprint_stage "active" events must fire
+        const phaseActives = chunks
+            .filter((c) => c.type === "council_phase" &&
+            c.councilPhase?.kind ===
+                "sprint_stage" &&
+            c.councilPhase?.state === "active")
+            .map((c) => c.councilPhase.phaseId);
+        expect(phaseActives).toContain("sprint-1-planning");
+        expect(phaseActives).toContain("sprint-1-implementation");
+        expect(phaseActives).toContain("sprint-1-verification");
+        expect(phaseActives).toContain("sprint-1-judgment");
+        // processMessageFn was called with the locked plan synthesisText
+        expect(processMessageFn).toHaveBeenCalledTimes(1);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        expect(processMessageFn.mock.calls[0][0]).toContain("Sprint plan locked");
+    });
+});
+// ── A3: phaseDone fires even when processMessageFn throws ─────────────────
+describe("A3: sprint-runner emits phaseDone even when processMessageFn throws", () => {
+    it("emits phaseError for implementation and throws, but does NOT leave phase stuck in active", async () => {
+        runCouncil.mockImplementation(async function* () {
+            yield { type: "content", content: "planning..." };
+            return "do the thing";
+        });
+        const ctx = {
+            runId: "run-a3-test",
+            flowDir: "/tmp/flow-a3",
+            cwd: "/tmp/cwd-a3",
+            idea: "test idea",
+            sessionModelId: "test-model",
+            llm: {
+                generate: vi.fn(async () => "synthesis"),
+                research: vi.fn(async () => "research"),
+            },
+            flags: { maxCost: 100, maxSprints: 5, doneThreshold: 0.9 },
+            respondToQuestion: vi.fn(),
+            respondToPreflight: vi.fn(),
+            // processMessageFn throws mid-stream
+            processMessageFn: vi.fn(async function* () {
+                yield { type: "content", content: "partial work done..." };
+                throw new Error("executor failed mid-stream");
+            }),
+            detectVerifyRecipe: vi.fn(async () => ({
+                testCommands: ["npm test"],
+                coverage: 80,
+                shellInitCommands: [],
+            })),
+        };
+        const { chunks, error } = await drainWithResult(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
+        // An error was thrown (processMessageFn threw)
+        expect(error).toBeDefined();
+        expect(String(error)).toContain("executor failed mid-stream");
+        // The implementation phase MUST have a non-active close event (phaseError or phaseDone)
+        const implPhaseChunks = chunks
+            .filter((c) => c.type === "council_phase" &&
+            c.councilPhase?.phaseId ===
+                "sprint-1-implementation")
+            .map((c) => c.councilPhase.state);
+        // Must have "active" start
+        expect(implPhaseChunks).toContain("active");
+        // Must have "error" close (phaseError was yielded via try/finally)
+        expect(implPhaseChunks).toContain("error");
+        // Must NOT end stuck in only "active" (i.e., must have both active and error)
+        expect(implPhaseChunks.length).toBeGreaterThanOrEqual(2);
+    });
+    it("emits phaseDone for implementation even when processMessageFn is absent (skip path)", async () => {
+        runCouncil.mockImplementation(async function* () {
+            yield { type: "content", content: "planning..." };
+            return "plan text";
+        });
+        const ctx = {
+            runId: "run-a3-skip",
+            flowDir: "/tmp/flow-a3-skip",
+            cwd: "/tmp/cwd-a3-skip",
+            idea: "test idea",
+            sessionModelId: "test-model",
+            llm: {
+                generate: vi.fn(async () => "synthesis"),
+                research: vi.fn(async () => "research"),
+            },
+            flags: { maxCost: 100, maxSprints: 5, doneThreshold: 0.9 },
+            respondToQuestion: vi.fn(),
+            respondToPreflight: vi.fn(),
+            // No processMessageFn — should emit phaseDone on skip path
+            processMessageFn: undefined,
+            detectVerifyRecipe: vi.fn(async () => ({
+                testCommands: ["npm test"],
+                coverage: 80,
+                shellInitCommands: [],
+            })),
+        };
+        const { chunks } = await drainWithResult(runSprint({ sprintN: 1, ctx: ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
+        const implPhaseChunks = chunks
+            .filter((c) => c.type === "council_phase" &&
+            c.councilPhase?.phaseId ===
+                "sprint-1-implementation")
+            .map((c) => c.councilPhase.state);
+        expect(implPhaseChunks).toContain("active");
+        expect(implPhaseChunks).toContain("done");
+    });
+});
+//# sourceMappingURL=phase-a1-a3-sprint-runner.test.js.map

package/dist/src/product-loop/__tests__/phase-a2-backlog-build.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * phase-a2-backlog-build.test.ts — Phase A2 unit tests.
+ *
+ * A2: buildBacklogAndSprintPlan builds backlog.json + sprint-plan.json after
+ *     the council debate produces a ProductSpec. Verified end-to-end via
+ *     runProductLoop (backlog-store + sprint-store real writes to tmpdir).
+ */
+export {};

package/dist/src/product-loop/__tests__/phase-a2-backlog-build.test.js

@@ -0,0 +1,162 @@
+/**
+ * phase-a2-backlog-build.test.ts — Phase A2 unit tests.
+ *
+ * A2: buildBacklogAndSprintPlan builds backlog.json + sprint-plan.json after
+ *     the council debate produces a ProductSpec. Verified end-to-end via
+ *     runProductLoop (backlog-store + sprint-store real writes to tmpdir).
+ */
+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";
+// ── Top-level mocks ────────────────────────────────────────────────────────
+vi.mock("../sprint-runner.js", () => ({
+    runSprint: vi.fn(),
+}));
+vi.mock("../loop-driver.js", () => ({
+    runLoopDriver: 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(),
+}));
+vi.mock("../artifact-io.js", () => ({
+    appendIteration: vi.fn(async () => undefined),
+    readCriteria: vi.fn(async () => []),
+    writeManifest: vi.fn(async () => undefined),
+    readManifest: vi.fn(async () => null),
+    markIterationCrashed: vi.fn(async () => undefined),
+    readIterations: vi.fn(async () => []),
+}));
+vi.mock("../discovery-persistence.js", () => ({
+    readProjectContext: vi.fn(async () => null),
+}));
+vi.mock("../gather.js", () => ({
+    clarifiedSpecFromContext: vi.fn(() => ({
+        problemStatement: "test",
+        constraints: [],
+        successCriteria: ["mvp feat"],
+        scope: "test",
+        rawQA: [],
+        resolved: {},
+    })),
+}));
+import { runProductLoop } from "../index.js";
+import { runLoopDriver } from "../loop-driver.js";
+import { runSprint } from "../sprint-runner.js";
+// ── Helpers ────────────────────────────────────────────────────────────────
+function shippedIter(sprintN = 1) {
+    return {
+        sprintN,
+        stage: "shipped",
+        scoreBefore: 0,
+        scoreAfter: 1.0,
+        criteriaMet: 1,
+        criteriaPartial: 0,
+        criteriaUnmet: 0,
+        costUsd: 0,
+        lastVerifyResult: "PASS",
+    };
+}
+async function drain(gen) {
+    while (true) {
+        const step = await gen.next();
+        if (step.done)
+            break;
+    }
+}
+function makeOpts(flowDir) {
+    return {
+        flowDir,
+        idea: "build a todo app",
+        subcommand: "start",
+        sessionModelId: "test-model",
+        sessionId: "test-session",
+        // mode="new" bypasses Mode C auto-detection
+        mode: "new",
+        llm: {
+            generate: vi.fn(async () => '{"idea":"todo","persona":"users","mvp":["add task"],"phase2":[],"architecture":"spa","ioContract":"rest","folderStructure":"src/","sprintEstimate":2,"costEstimate":10}'),
+            research: vi.fn(async () => ""),
+            debate: vi.fn(async () => ""),
+        },
+        flags: { maxCost: 50, maxSprints: 2, doneThreshold: 0.9, forceCouncil: true },
+        respondToQuestion: vi.fn(async () => "answer"),
+        respondToPreflight: vi.fn(async () => true),
+        processMessageFn: vi.fn(async function* () {
+            yield { type: "content", content: "ok" };
+        }),
+        // detectVerifyRecipe returns null so Mode C does NOT activate
+        detectVerifyRecipe: vi.fn(async () => null),
+    };
+}
+// ── Tests ──────────────────────────────────────────────────────────────────
+describe("A2: buildBacklogAndSprintPlan writes backlog.json + sprint-plan.json", () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "phase-a2-test-"));
+        vi.clearAllMocks();
+        // Driver returns approved
+        runLoopDriver.mockImplementation(async function* () {
+            yield { type: "content", content: "running driver" };
+            return { success: true, stage: "approved" };
+        });
+        // Sprint runner returns shipped immediately. async function* with no
+        // yield is the correct shape for runSprint (AsyncGenerator<StreamChunk,
+        // IterationState>) — only the IterationState return matters here.
+        // biome-ignore lint/correctness/useYield: intentional no-yield mock
+        runSprint.mockImplementation(async function* () {
+            return shippedIter(1);
+        });
+    });
+    afterEach(async () => {
+        // Windows ENOTEMPTY guard — see plan.test.ts:33 for rationale.
+        await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+    });
+    it("creates backlog.json and sprint-plan.json when they do not exist", async () => {
+        await drain(runProductLoop(makeOpts(tmpDir)));
+        // Look for backlog.json + sprint-plan.json in .planning/runs/<runId>/
+        const runsDir = path.join(tmpDir, "runs");
+        const runDirs = await fs.readdir(runsDir).catch(() => []);
+        let backlogFound = false;
+        let sprintPlanFound = false;
+        for (const runId of runDirs) {
+            const base = path.join(runsDir, runId);
+            await fs
+                .access(path.join(base, "backlog.json"))
+                .then(() => {
+                backlogFound = true;
+            })
+                .catch(() => { });
+            await fs
+                .access(path.join(base, "sprint-plan.json"))
+                .then(() => {
+                sprintPlanFound = true;
+            })
+                .catch(() => { });
+        }
+        expect(backlogFound).toBe(true);
+        expect(sprintPlanFound).toBe(true);
+    });
+    it("is idempotent — skips build if backlog.json already exists", async () => {
+        // First run — creates backlog + sprint-plan
+        await drain(runProductLoop(makeOpts(tmpDir)));
+        const runsDir = path.join(tmpDir, "runs");
+        const runDirs1 = await fs.readdir(runsDir).catch(() => []);
+        const runId1 = runDirs1[0];
+        expect(runId1).toBeDefined();
+        const backlogPath = path.join(runsDir, runId1, "backlog.json");
+        const backlogStat1 = await fs.stat(backlogPath).catch(() => null);
+        expect(backlogStat1).not.toBeNull();
+        // Re-mock with a spy to detect if LLM is called again for backlog build
+        const llmGenSpy = vi.fn(async () => '{"idea":"todo","persona":"users","mvp":["add task"],"phase2":[],"architecture":"spa","ioContract":"rest","folderStructure":"src/","sprintEstimate":2,"costEstimate":10}');
+        const opts2 = { ...makeOpts(tmpDir), llm: { ...makeOpts(tmpDir).llm, generate: llmGenSpy } };
+        // Second run with same flowDir — should reuse existing backlog + sprint-plan
+        await drain(runProductLoop(opts2));
+        // backlog.json mtime must be unchanged (idempotent — not re-written)
+        const backlogStat2 = await fs.stat(backlogPath).catch(() => null);
+        expect(backlogStat2?.mtimeMs).toBe(backlogStat1?.mtimeMs);
+    });
+});
+//# sourceMappingURL=phase-a2-backlog-build.test.js.map

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

@@ -2,7 +2,7 @@ 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 { generateSprintReview, runRetro, runStandup, shouldRunStandup, } from "../phase-rituals.js";
+import { generateSprintReview, runRetro, runStandup, shouldRunStandup } from "../phase-rituals.js";
 describe("generateSprintReview (subsystem E)", () => {
     const sprintState = {
         sprintN: 1,

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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,95 @@
+/**
+ * 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__/progress-snapshot.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 {};