muonroi-cli 1.3.4 → 1.4.1

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

@@ -0,0 +1,152 @@
+/**
+ * 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.
+ */
+import { mkdtemp, rm } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { writeBacklog } from "../backlog-store.js";
+import { writeSprintPlan } from "../sprint-store.js";
+// ─── Mock DB ──────────────────────────────────────────────────────────────────
+// Default: no sprint_stage rows
+const mockDbGet = vi.fn().mockReturnValue(undefined);
+const mockDbPrepare = vi.fn().mockReturnValue({ get: mockDbGet });
+vi.mock("../../storage/db.js", () => ({
+    getDatabase: vi.fn(() => ({ prepare: mockDbPrepare })),
+}));
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await mkdtemp(path.join(os.tmpdir(), "progress-snapshot-test-"));
+    mockDbGet.mockReturnValue(undefined); // reset to "no rows"
+});
+afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+});
+function makeItem(overrides) {
+    const now = new Date().toISOString();
+    return {
+        title: overrides.id,
+        description: "",
+        acceptance_criteria: ["crit-1", "crit-2"],
+        entities: [],
+        endpoints: [],
+        mvp_priority: "v1",
+        status: "backlog",
+        effortPoints: 3,
+        createdAtUtc: now,
+        updatedAtUtc: now,
+        ...overrides,
+    };
+}
+function makeBacklog(items) {
+    return {
+        runId: "run-1",
+        productSlug: "test-product",
+        items,
+        derivedFromClarifyId: "abc",
+        createdAtUtc: new Date().toISOString(),
+    };
+}
+function makeSprint(overrides) {
+    return {
+        goal: `Goal for ${overrides.id}`,
+        itemIds: [],
+        status: "planned",
+        ...overrides,
+    };
+}
+function makeSprintPlan(sprints, activeSprintId) {
+    return {
+        runId: "run-1",
+        sprints,
+        activeSprintId,
+        createdAtUtc: new Date().toISOString(),
+    };
+}
+describe("computeProgressSnapshot", () => {
+    it("empty workspace returns all-zero snapshot without crashing", async () => {
+        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
+        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "prod" });
+        expect(snap.backlogTotal).toBe(0);
+        expect(snap.backlogV1Count).toBe(0);
+        expect(snap.sprintTotal).toBe(0);
+        expect(snap.activeSprintNumber).toBeNull();
+        expect(snap.activeSprintPercentDone).toBe(0);
+        expect(snap.activeSprintItems).toHaveLength(0);
+        expect(snap.blockers).toHaveLength(0);
+        expect(snap.workerCurrentStage).toBeNull();
+    });
+    it("9 items / 3 sprints / 3 items done in active sprint → percentDone = 100", async () => {
+        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
+        const items = [
+            makeItem({ id: "i1", status: "done", assigned_sprint: "sprint-1" }),
+            makeItem({ id: "i2", status: "done", assigned_sprint: "sprint-1" }),
+            makeItem({ id: "i3", status: "done", assigned_sprint: "sprint-1" }),
+            makeItem({ id: "i4", status: "backlog", assigned_sprint: "sprint-2" }),
+            makeItem({ id: "i5", status: "backlog", assigned_sprint: "sprint-2" }),
+            makeItem({ id: "i6", status: "backlog", assigned_sprint: "sprint-2" }),
+            makeItem({ id: "i7", status: "backlog", assigned_sprint: "sprint-3" }),
+            makeItem({ id: "i8", status: "backlog", assigned_sprint: "sprint-3" }),
+            makeItem({ id: "i9", status: "backlog", assigned_sprint: "sprint-3" }),
+        ];
+        const backlog = makeBacklog(items);
+        await writeBacklog(tmpDir, "run-1", backlog);
+        const sprints = [
+            makeSprint({ id: "sprint-1", number: 1, status: "active", itemIds: ["i1", "i2", "i3"] }),
+            makeSprint({ id: "sprint-2", number: 2, status: "planned", itemIds: ["i4", "i5", "i6"] }),
+            makeSprint({ id: "sprint-3", number: 3, status: "planned", itemIds: ["i7", "i8", "i9"] }),
+        ];
+        const plan = makeSprintPlan(sprints, "sprint-1");
+        await writeSprintPlan(tmpDir, "run-1", plan);
+        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "test-product" });
+        expect(snap.sprintTotal).toBe(3);
+        expect(snap.activeSprintNumber).toBe(1);
+        expect(snap.activeSprintPercentDone).toBe(100);
+        expect(snap.activeSprintItems).toHaveLength(3);
+    });
+    it("workerCurrentStage parsed from interaction_logs", async () => {
+        mockDbGet.mockReturnValue({
+            metadata_json: JSON.stringify({ sprintIndex: 2, stage: "planning" }),
+            created_at: "2026-05-21T10:00:00.000Z",
+        });
+        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
+        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "prod" });
+        expect(snap.workerCurrentStage).toBe("Sprint 2 — Planning");
+        expect(snap.workerLastEventUtc).toBe("2026-05-21T10:00:00.000Z");
+    });
+    it("blockers detected for blocked items in active sprint", async () => {
+        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
+        const items = [
+            makeItem({ id: "b1", status: "blocked", assigned_sprint: "sprint-1", blockers: ["b2"] }),
+            makeItem({ id: "b2", status: "backlog", assigned_sprint: "sprint-1" }),
+        ];
+        const backlog = makeBacklog(items);
+        await writeBacklog(tmpDir, "run-1", backlog);
+        const sprints = [makeSprint({ id: "sprint-1", number: 1, status: "active", itemIds: ["b1", "b2"] })];
+        const plan = makeSprintPlan(sprints, "sprint-1");
+        await writeSprintPlan(tmpDir, "run-1", plan);
+        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "test-product" });
+        expect(snap.blockers).toHaveLength(1);
+        expect(snap.blockers[0].itemId).toBe("b1");
+        expect(snap.blockers[0].reason).toContain("blocked by b2");
+    });
+    it("no active sprint → activeSprintNumber is null", async () => {
+        const { computeProgressSnapshot } = await import("../progress-snapshot.js");
+        const items = [makeItem({ id: "x", status: "in_sprint", assigned_sprint: "sprint-1" })];
+        const backlog = makeBacklog(items);
+        await writeBacklog(tmpDir, "run-1", backlog);
+        const sprints = [makeSprint({ id: "sprint-1", number: 1, status: "planned", itemIds: ["x"] })];
+        const plan = makeSprintPlan(sprints); // no activeSprintId
+        await writeSprintPlan(tmpDir, "run-1", plan);
+        const snap = await computeProgressSnapshot({ flowDir: tmpDir, runId: "run-1", productSlug: "test-product" });
+        expect(snap.activeSprintNumber).toBeNull();
+        expect(snap.activeSprintGoal).toBeNull();
+        expect(snap.activeSprintItems).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=progress-snapshot.test.js.map

package/dist/src/product-loop/__tests__/repo-audit.test.js

@@ -16,7 +16,7 @@ describe("auditRepo", () => {
     let cwd;
     afterEach(async () => {
         if (cwd)
-            await fs.rm(cwd, { recursive: true, force: true });
+            await fs.rm(cwd, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
     });
     it("returns greenfield mode for empty cwd", async () => {
         cwd = await makeFixture({});

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

@@ -0,0 +1,9 @@
+/**
+ * Tests for `buildRepoBrief` — the existing-project replacement for the
+ * Muonroi vendor preamble in discovery leader prompts. Covers:
+ *  - basic shape from a TS-ish temp repo
+ *  - missing pieces (no README, no package.json) degrade gracefully
+ *  - rationaleCitesBrief gate accepts cited and rejects uncited rationales
+ *  - hard cap respected on large READMEs
+ */
+export {};

package/dist/src/product-loop/__tests__/repo-brief.test.js

@@ -0,0 +1,132 @@
+/**
+ * Tests for `buildRepoBrief` — the existing-project replacement for the
+ * Muonroi vendor preamble in discovery leader prompts. Covers:
+ *  - basic shape from a TS-ish temp repo
+ *  - missing pieces (no README, no package.json) degrade gracefully
+ *  - rationaleCitesBrief gate accepts cited and rejects uncited rationales
+ *  - hard cap respected on large READMEs
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { buildRepoBrief, rationaleCitesBrief } from "../repo-brief.js";
+function makeDetection(over = {}) {
+    return {
+        isGitRepo: false,
+        hasCommitHistory: false,
+        srcFileCount: 10,
+        manifests: [],
+        languages: ["TypeScript"],
+        frameworks: [],
+        classification: "existing",
+        ...over,
+    };
+}
+describe("buildRepoBrief", () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs.mkdtempSync(path.join(os.tmpdir(), "muonroi-repo-brief-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+    });
+    it("includes package.json name, scripts, deps when present", async () => {
+        fs.writeFileSync(path.join(tmp, "package.json"), JSON.stringify({
+            name: "@muonroi/test-pkg",
+            description: "Test pkg for repo-brief",
+            scripts: { build: "tsc", test: "vitest" },
+            dependencies: { ai: "^1.0.0", vitest: "^4.0.0" },
+        }));
+        const brief = await buildRepoBrief(tmp, makeDetection());
+        expect(brief.markdown).toContain("@muonroi/test-pkg");
+        expect(brief.markdown).toContain("Test pkg for repo-brief");
+        expect(brief.markdown).toContain("`build`");
+        expect(brief.markdown).toContain("`ai`");
+        expect(brief.citableTokens).toContain("@muonroi/test-pkg");
+        expect(brief.citableTokens).toContain("build");
+        expect(brief.citableTokens).toContain("ai");
+    });
+    it("walks top-level dirs to depth 2 and skips ignored dirs", async () => {
+        fs.mkdirSync(path.join(tmp, "src", "components"), { recursive: true });
+        fs.mkdirSync(path.join(tmp, "src", "hooks"), { recursive: true });
+        fs.mkdirSync(path.join(tmp, "node_modules", "foo"), { recursive: true });
+        fs.mkdirSync(path.join(tmp, ".git"), { recursive: true });
+        fs.mkdirSync(path.join(tmp, "tests"), { recursive: true });
+        const brief = await buildRepoBrief(tmp, makeDetection());
+        expect(brief.markdown).toContain("`src/`");
+        expect(brief.markdown).toContain("`components/`");
+        expect(brief.markdown).toContain("`hooks/`");
+        expect(brief.markdown).toContain("`tests/`");
+        expect(brief.markdown).not.toContain("node_modules");
+        expect(brief.markdown).not.toContain(".git");
+        expect(brief.citableTokens).toContain("src");
+        expect(brief.citableTokens).toContain("src/components");
+    });
+    it("includes README head and truncates with ellipsis", async () => {
+        const big = "X".repeat(900);
+        fs.writeFileSync(path.join(tmp, "README.md"), `# Title\n\n${big}`);
+        const brief = await buildRepoBrief(tmp, makeDetection());
+        expect(brief.markdown).toContain("README head:");
+        expect(brief.markdown).toContain("# Title");
+        expect(brief.markdown).toContain("…");
+    });
+    it("includes manifests + languages + frameworks from detection", async () => {
+        const brief = await buildRepoBrief(tmp, makeDetection({
+            languages: ["TypeScript", "Rust"],
+            frameworks: ["react", "vite"],
+            manifests: [
+                {
+                    file: path.join(tmp, "package.json"),
+                    type: "package.json",
+                    weight: 1,
+                    inferredLang: "TypeScript",
+                    inferredFrameworks: ["react"],
+                },
+            ],
+        }));
+        expect(brief.markdown).toContain("TypeScript, Rust");
+        expect(brief.markdown).toContain("react, vite");
+        expect(brief.markdown).toContain("package.json");
+        expect(brief.citableTokens).toContain("react");
+        expect(brief.citableTokens).toContain("package.json");
+    });
+    it("degrades gracefully when nothing is present (empty dir)", async () => {
+        const brief = await buildRepoBrief(tmp, makeDetection({ languages: [], srcFileCount: 0 }));
+        expect(brief.markdown).toContain("Repo brief");
+        expect(brief.markdown).toContain("Rationales for ANY recommendation MUST cite");
+        // citableTokens may still be empty for an empty dir — acceptable.
+        expect(Array.isArray(brief.citableTokens)).toBe(true);
+    });
+    it("caps total markdown length at 1200 chars", async () => {
+        fs.writeFileSync(path.join(tmp, "README.md"), "Z".repeat(5000));
+        fs.writeFileSync(path.join(tmp, "package.json"), JSON.stringify({
+            name: "x",
+            scripts: Object.fromEntries(Array.from({ length: 30 }, (_, i) => [`s${i}`, `cmd${i}`])),
+            dependencies: Object.fromEntries(Array.from({ length: 50 }, (_, i) => [`dep${i}`, "1"])),
+        }));
+        const brief = await buildRepoBrief(tmp, makeDetection());
+        expect(brief.markdown.length).toBeLessThanOrEqual(1200);
+    });
+});
+describe("rationaleCitesBrief", () => {
+    const briefStub = {
+        markdown: "(unused)",
+        citableTokens: ["src", "package.json", "discovery-recommender.ts", "build"],
+    };
+    it("returns true when rationale contains any token (case-insensitive)", () => {
+        expect(rationaleCitesBrief("Reuses `src/foo.ts` to avoid duplication", briefStub)).toBe(true);
+        expect(rationaleCitesBrief("Extends the existing BUILD script", briefStub)).toBe(true);
+    });
+    it("returns false when rationale is generic / cites nothing in brief", () => {
+        expect(rationaleCitesBrief("Industry standard for SaaS apps", briefStub)).toBe(false);
+        expect(rationaleCitesBrief("Best for performance and simplicity", briefStub)).toBe(false);
+    });
+    it("returns true when brief has no citable tokens (no expectations to enforce)", () => {
+        expect(rationaleCitesBrief("anything", { markdown: "", citableTokens: [] })).toBe(true);
+    });
+    it("returns true when brief is undefined", () => {
+        expect(rationaleCitesBrief("anything", undefined)).toBe(true);
+    });
+});
+//# sourceMappingURL=repo-brief.test.js.map

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

@@ -10,7 +10,9 @@
 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 { 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(),
 }));
@@ -26,9 +28,53 @@ vi.mock("../../ee/phase-outcome.js", () => ({
 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
 // ---------------------------------------------------------------------------
@@ -62,7 +108,7 @@ function makeOpts(flowDir, overrides = {}) {
         flowDir,
         idea: "build something",
         subcommand: "start",
-        sessionModelId: "claude-sonnet-4-6",
+        sessionModelId: getTestModels().balanced,
         sessionId: "test-session-id",
         llm: { generate: vi.fn(async () => ""), research: vi.fn(async () => "") },
         flags: { maxCost: 50, maxSprints: 8, doneThreshold: 0.9 },
@@ -72,6 +118,9 @@ function makeOpts(flowDir, overrides = {}) {
             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,
     };
 }

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

@@ -27,7 +27,7 @@ describe("polishDelivery", () => {
     const cleanups = [];
     afterEach(async () => {
         for (const c of cleanups) {
-            await fs.rm(c, { recursive: true, force: true });
+            await fs.rm(c, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
         }
         cleanups.length = 0;
     });

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

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

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

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

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

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