muonroi-cli 1.4.0 → 1.5.0

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

@@ -1,501 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// All external modules are mocked so the test exercises only sprint-runner orchestration.
-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(),
-  readCriteria: 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"),
-}));
-
-import { runCouncil } from "../../council/index.js";
-import { release } from "../../usage/ledger.js";
-import { CapBreachError } from "../../usage/types.js";
-import { runVerifyOrchestration } from "../../verify/orchestrator.js";
-import { appendIteration } from "../artifact-io.js";
-import { CB1_costProjection, CB2_oscillation, CB3_verifyBlank } from "../circuit-breakers.js";
-import { reserveForProduct } from "../cost-scoper.js";
-import { evaluateDoneGate } from "../done-gate.js";
-import { postSprintBoundary } from "../phase-tracker-bridge.js";
-import { runSprint } from "../sprint-runner.js";
-import type { IterationState, ProductSpec, RoleSlot } from "../types.js";
-
-function makeCtx(overrides: any = {}): any {
-  return {
-    runId: "run-123",
-    flowDir: "/tmp/flow",
-    cwd: "/tmp/cwd",
-    idea: "test idea",
-    llm: { generate: vi.fn(async () => "synthesis text"), research: vi.fn(async () => "research") },
-    flags: { maxCost: 100, maxSprints: 5, doneThreshold: 0.9 },
-    respondToQuestion: vi.fn(),
-    respondToPreflight: vi.fn(),
-    processMessageFn: vi.fn(async function* () {
-      yield { type: "content", content: "implementing..." };
-    }),
-    detectVerifyRecipe: vi.fn(async () => ({
-      testCommands: ["npm test"],
-      coverage: 80,
-      shellInitCommands: [],
-    })),
-    ...overrides,
-  };
-}
-
-function makeSpec(): ProductSpec {
-  return {
-    idea: "test idea",
-    persona: "users",
-    mvp: ["feat1"],
-    phase2: [],
-    architecture: "arch",
-    ioContract: "io",
-    folderStructure: "src/",
-    sprintEstimate: 2,
-    costEstimate: 10,
-    createdAt: new Date(),
-  };
-}
-
-const NO_ROLES = new Map<RoleSlot, { modelId: string; provider: string; tier?: string }>();
-
-async function drain<T, R>(
-  gen: AsyncGenerator<T, R, unknown>,
-): Promise<{ chunks: T[]; result: R | undefined; error?: unknown }> {
-  const chunks: T[] = [];
-  try {
-    while (true) {
-      const { value, done } = await gen.next();
-      if (done) return { chunks, result: value as R };
-      chunks.push(value);
-    }
-  } catch (error) {
-    return { chunks, result: undefined, error };
-  }
-}
-
-describe("sprint-runner", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    (CB1_costProjection as any).mockReturnValue({ halt: false, projection: 0, headroom: 100 });
-    (CB2_oscillation as any).mockReturnValue({ halt: false, delta_t: 0, delta_t_minus_1: 0 });
-    (CB3_verifyBlank as any).mockReturnValue({ halt: false });
-    (evaluateDoneGate as any).mockResolvedValue({ pass: true, score: 1.0 });
-    (runVerifyOrchestration as any).mockResolvedValue({
-      success: true,
-      output: "VERIFY_PASS\n",
-      verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-    });
-    (runCouncil as any).mockImplementation(async function* () {
-      yield { type: "content", content: "council planning..." };
-      return "synthesis text from council";
-    });
-  });
-
-  it("happy path: plan → implement → verify → judge → return passing IterationState", async () => {
-    const ctx = makeCtx();
-    const gen = runSprint({
-      sprintN: 1,
-      ctx,
-      productSpec: makeSpec(),
-      roleAssignments: NO_ROLES,
-      history: [],
-    });
-
-    const { chunks, result } = await drain(gen);
-    expect(result).toBeDefined();
-    expect(result!.sprintN).toBe(1);
-    expect(result!.scoreAfter).toBe(1.0);
-    expect(result!.lastVerifyResult).toBe("PASS");
-    expect(result!.stage).toBe("shipped");
-
-    expect(runCouncil).toHaveBeenCalledTimes(1);
-    expect(ctx.processMessageFn).toHaveBeenCalled(); // implementation step
-    expect(runVerifyOrchestration).toHaveBeenCalledTimes(1);
-    expect(evaluateDoneGate).toHaveBeenCalledTimes(1);
-    expect(appendIteration).toHaveBeenCalledTimes(1);
-    expect(postSprintBoundary).toHaveBeenCalledWith(expect.objectContaining({ outcome: "pass", sprintN: 1 }));
-    expect(chunks.some((c: any) => c.type === "content")).toBe(true);
-  });
-
-  it("CB-3 trips on sprint 1 with missing recipe — yields halt chunk BEFORE planner runs", async () => {
-    (CB3_verifyBlank as any).mockReturnValue({ halt: true, reason: "no_recipe" });
-    const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-    const { chunks, error } = await drain(
-      runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-    // Must yield a structured halt chunk, not throw.
-    expect(error).toBeUndefined();
-    const haltChunks = chunks.filter((c: any) => c.type === "halt");
-    expect(haltChunks).toHaveLength(1);
-    expect(haltChunks[0]).toMatchObject({
-      type: "halt",
-      haltChunk: {
-        reason: "no_recipe",
-        recovery_options: expect.arrayContaining([
-          expect.objectContaining({ id: "init_new" }),
-          expect.objectContaining({ id: "point_to_existing" }),
-          expect.objectContaining({ id: "continue_as_council" }),
-        ]),
-      },
-    });
-    expect((haltChunks[0] as any).haltChunk.recovery_options).toHaveLength(3);
-    expect(runCouncil).not.toHaveBeenCalled();
-    expect(runVerifyOrchestration).not.toHaveBeenCalled();
-  });
-
-  // CB-1 is intentionally disabled in sprint-runner (see comment at "Step 1").
-  // Provider pricing gaps produced false halts; re-enable once cost
-  // normalisation is reliable.
-  it.skip("CB-1 trips when projected cost exceeds 1.5x remaining headroom", async () => {
-    (CB1_costProjection as any).mockReturnValue({ halt: true, projection: 50, headroom: 5 });
-    const ctx = makeCtx();
-    const { error } = await drain(
-      runSprint({ sprintN: 4, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-    expect((error as Error).message).toContain("cost projection");
-    expect(runCouncil).not.toHaveBeenCalled();
-  });
-
-  it("CB-2 trips when last 2 deltas are non-positive at sprint >= 3", async () => {
-    (CB2_oscillation as any).mockReturnValue({ halt: true, delta_t: -0.05, delta_t_minus_1: 0 });
-    (evaluateDoneGate as any).mockResolvedValue({ pass: false, failedCondition: "weighted_score", score: 0.4 });
-
-    const history: IterationState[] = [
-      {
-        sprintN: 3,
-        stage: "retrospective",
-        scoreBefore: 0.5,
-        scoreAfter: 0.5,
-        criteriaMet: 0,
-        criteriaPartial: 0,
-        criteriaUnmet: 0,
-        costUsd: 0,
-        lastVerifyResult: "PASS",
-      },
-      {
-        sprintN: 4,
-        stage: "retrospective",
-        scoreBefore: 0.5,
-        scoreAfter: 0.5,
-        criteriaMet: 0,
-        criteriaPartial: 0,
-        criteriaUnmet: 0,
-        costUsd: 0,
-        lastVerifyResult: "PASS",
-      },
-    ];
-    const ctx = makeCtx();
-    const { error } = await drain(
-      runSprint({ sprintN: 5, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history }),
-    );
-    expect((error as Error).message).toContain("oscillation");
-  });
-
-  it("Done-gate Cond #1 fail: returns IterationState with verify-result and continue-feedback chunk emitted", async () => {
-    (evaluateDoneGate as any).mockResolvedValue({
-      pass: false,
-      failedCondition: "engineering_floor",
-      score: 0.4,
-      reason: "verify_FAIL",
-    });
-    (runVerifyOrchestration as any).mockResolvedValue({
-      success: false,
-      output: "VERIFY_FAIL\nTests failed",
-      verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-    });
-
-    const ctx = makeCtx();
-    const { chunks, result } = await drain(
-      runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-    expect(result!.stage).toBe("retrospective");
-    expect(result!.lastVerifyResult).toBe("FAIL");
-    const continueChunk = chunks.find((c: any) => typeof c.content === "string" && c.content.includes("Next focus"));
-    expect(continueChunk).toBeDefined();
-  });
-
-  it("releases reservation when council generate throws (no leaked reservations)", async () => {
-    // Force the planner to call llm.generate which throws — ensure release is invoked.
-    (reserveForProduct as any).mockResolvedValue({
-      id: "tok",
-      model: "m",
-      provider: "p",
-      projected_usd: 0.1,
-      est_input_tokens: 1,
-      est_output_tokens: 1,
-      createdAtMs: Date.now(),
-    });
-    // Make council itself yield, then trigger an error on the implementation pass.
-    (runCouncil as any).mockImplementation(async function* () {
-      yield { type: "content", content: "planning" };
-      return "plan-text";
-    });
-    // Drive base llm.generate via product-llm wrapper inside the test indirectly:
-    // since council is mocked to NOT call llm, we simulate by directly invoking
-    // the sprint-runner happy path and then asserting release is NOT called when
-    // there is no failure. Then a separate path: cap breach.
-    const ctx = makeCtx();
-    const { result } = await drain(
-      runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-    expect(result).toBeDefined();
-    // No error, so release should NOT have been called by the wrapper.
-    expect(release).not.toHaveBeenCalled();
-  });
-
-  it("propagates CapBreachError as readable Error from product-LLM wrapper", async () => {
-    // Trigger reserveForProduct to return a CapBreachError during the LLM call inside the
-    // wrapper. We invoke the wrapper indirectly by having runCouncil call ctx.llm.generate
-    // through the wrapper. The simplest way is to check that the cost-scoper signals
-    // breach correctly when invoked manually — covered already by cost-scoper tests.
-    // Here we just ensure that if reserveForProduct surfaces a breach, the wrapper rethrows.
-    (reserveForProduct as any).mockResolvedValue(new CapBreachError(40, 5, 10, 50));
-
-    // Simulate by importing the wrapper indirectly via runSprint: drive llm through
-    // a custom test by providing a council mock that calls llm.generate.
-    (runCouncil as any).mockImplementation(async function* (
-      _topic: string,
-      _model: string,
-      _msgs: any,
-      _sid: string,
-      llm: any,
-    ) {
-      // Invoke the wrapped llm — this should throw inside the wrapper.
-      yield { type: "content", content: "planning" };
-      await llm.generate("m", "sys", "prompt");
-      return "unreachable";
-    });
-
-    const ctx = makeCtx();
-    const { error } = await drain(
-      runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-    expect((error as Error).message).toMatch(/Cost cap breached/);
-  });
-});
-
-describe("sprint-runner phaseScope (subsystem E)", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    (CB1_costProjection as any).mockReturnValue({ halt: false, projection: 0, headroom: 100 });
-    (CB2_oscillation as any).mockReturnValue({ halt: false, delta_t: 0, delta_t_minus_1: 0 });
-    (CB3_verifyBlank as any).mockReturnValue({ halt: false });
-    (runVerifyOrchestration as any).mockResolvedValue({
-      success: true,
-      output: "VERIFY_PASS\n",
-      verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-    });
-    (runCouncil as any).mockImplementation(async function* () {
-      yield { type: "content", content: "council planning..." };
-      return "synthesis text from council";
-    });
-  });
-
-  it("when phaseScope present, evaluateDoneGate receives only the scoped subset of criteria", async () => {
-    // Arrange: readCriteria returns 3 criteria; phaseScope restricts to 2 of them.
-    const { readCriteria } = await import("../artifact-io.js");
-    (readCriteria as any).mockResolvedValue([
-      { id: "crit-A", status: "met" },
-      { id: "crit-B", status: "unmet" },
-      { id: "crit-C", status: "partial" },
-    ]);
-    (evaluateDoneGate as any).mockResolvedValue({ pass: true, score: 1.0 });
-
-    const ctx = makeCtx();
-    const { result } = await drain(
-      runSprint({
-        sprintN: 1,
-        ctx,
-        productSpec: makeSpec(),
-        roleAssignments: NO_ROLES,
-        history: [],
-        phaseScope: { criteria: ["crit-A", "crit-B"], scope: "phase-1" },
-      }),
-    );
-
-    expect(result).toBeDefined();
-    // evaluateDoneGate must have been called with only the 2 scoped criteria, not all 3.
-    const gateCall = (evaluateDoneGate as any).mock.calls[0][0];
-    expect(gateCall.criteria).toHaveLength(2);
-    expect(gateCall.criteria.map((c: any) => c.id)).toEqual(["crit-A", "crit-B"]);
-  });
-
-  it("when phaseScope criteria don't match any Criterion.id, falls back to full set", async () => {
-    // Arrange: readCriteria returns 3 criteria with slug ids.
-    // phaseScope.criteria contains verbatim spec text that doesn't match any id.
-    const { readCriteria } = await import("../artifact-io.js");
-    (readCriteria as any).mockResolvedValue([
-      { id: "crit-A", status: "met" },
-      { id: "crit-B", status: "unmet" },
-      { id: "crit-C", status: "partial" },
-    ]);
-    (evaluateDoneGate as any).mockResolvedValue({ pass: true, score: 1.0 });
-
-    const ctx = makeCtx();
-    await drain(
-      runSprint({
-        sprintN: 1,
-        ctx,
-        productSpec: makeSpec(),
-        roleAssignments: NO_ROLES,
-        history: [],
-        phaseScope: {
-          criteria: ["All API endpoints return 200", "Database migrations complete"],
-          scope: "phase-1",
-        },
-      }),
-    );
-
-    // None of the verbatim strings match slug ids → permissive fallback → all 3 passed.
-    const gateCall = (evaluateDoneGate as any).mock.calls[0][0];
-    expect(gateCall.criteria).toHaveLength(3);
-  });
-
-  it("when phaseScope is absent, evaluateDoneGate receives all criteria (backwards-compat)", async () => {
-    const { readCriteria } = await import("../artifact-io.js");
-    (readCriteria as any).mockResolvedValue([
-      { id: "crit-A", status: "met" },
-      { id: "crit-B", status: "unmet" },
-      { id: "crit-C", status: "partial" },
-    ]);
-    (evaluateDoneGate as any).mockResolvedValue({ pass: true, score: 1.0 });
-
-    const ctx = makeCtx();
-    await drain(runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }));
-
-    const gateCall = (evaluateDoneGate as any).mock.calls[0][0];
-    expect(gateCall.criteria).toHaveLength(3);
-  });
-});
-
-// ── Task 5.1: call-site halt forwarding ─────────────────────────────────────
-// These tests exercise runSprint() directly (the only unit-testable path for the
-// halt chunk shape and forwarding semantics). The call-site logic in index.ts
-// (sites 1, 2, 3) uses the same discriminator pattern; testing the yielded shape
-// here proves the contract that all three sites consume.
-
-describe("sprint-runner halt chunk forwarding (Task 5.1)", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    (CB1_costProjection as any).mockReturnValue({ halt: false, projection: 0, headroom: 100 });
-    (CB2_oscillation as any).mockReturnValue({ halt: false, delta_t: 0, delta_t_minus_1: 0 });
-    (CB3_verifyBlank as any).mockReturnValue({ halt: false });
-    (evaluateDoneGate as any).mockResolvedValue({ pass: true, score: 1.0 });
-    (runVerifyOrchestration as any).mockResolvedValue({
-      success: true,
-      output: "VERIFY_PASS\n",
-      verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-    });
-    (runCouncil as any).mockImplementation(async function* () {
-      yield { type: "content", content: "council planning..." };
-      return "synthesis text from council";
-    });
-  });
-
-  it("call site 1 pattern — CB-3 halt chunk is yielded (not thrown) and contains 3 recovery options", async () => {
-    // Simulate what site 1 (runOneSprint) drives: runSprint with sprintN=1, no history.
-    (CB3_verifyBlank as any).mockReturnValue({ halt: true, reason: "no_recipe" });
-    const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-
-    const { chunks, error } = await drain(
-      runSprint({ sprintN: 1, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-
-    // No throw — error must be undefined.
-    expect(error).toBeUndefined();
-    // Halt chunk must be in the yielded stream.
-    const halt = chunks.find((c: any) => c.type === "halt");
-    expect(halt).toBeDefined();
-    expect(halt).toMatchObject({ type: "halt", haltChunk: { reason: "no_recipe" } });
-    expect((halt as any).haltChunk.recovery_options).toHaveLength(3);
-    // Planner and verifier must NOT have run.
-    expect(runCouncil).not.toHaveBeenCalled();
-    expect(runVerifyOrchestration).not.toHaveBeenCalled();
-  });
-
-  it("call site 2 pattern — CB-3 halt chunk is forwarded through multi-sprint drainSprints loop", async () => {
-    // Simulate what site 2 (drainSprints) drives: runSprint with sprintN >= 1, history may be non-empty.
-    (CB3_verifyBlank as any).mockReturnValue({ halt: true, reason: "no_recipe" });
-    const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-
-    // Drive with sprintN=2 to exercise the multi-sprint path in drainSprints.
-    const { chunks, error } = await drain(
-      runSprint({ sprintN: 2, ctx, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-
-    expect(error).toBeUndefined();
-    const halt = chunks.find((c: any) => c.type === "halt");
-    expect(halt).toBeDefined();
-    expect(halt).toMatchObject({ type: "halt", haltChunk: { reason: "no_recipe" } });
-    expect((halt as any).haltChunk.recovery_options).toHaveLength(3);
-  });
-
-  it("call site 3 pattern — CB-3 halt chunk is forwarded through phase-runner sprintRunner adapter", async () => {
-    // Simulate what site 3 (sprintRunner adapter inside runWithPhases) drives:
-    // runSprint called with phaseScope, no try/catch in the adapter.
-    (CB3_verifyBlank as any).mockReturnValue({ halt: true, reason: "no_recipe" });
-    const ctx = makeCtx({ detectVerifyRecipe: vi.fn(async () => null) });
-
-    const { chunks, error } = await drain(
-      runSprint({
-        sprintN: 1,
-        ctx,
-        productSpec: makeSpec(),
-        roleAssignments: NO_ROLES,
-        history: [],
-        phaseScope: { criteria: ["crit-A"], scope: "phase-1" },
-      }),
-    );
-
-    // Without the fix, the generator returned normally (halt silently consumed).
-    // With the fix, the halt chunk is in the yielded stream.
-    expect(error).toBeUndefined();
-    const halt = chunks.find((c: any) => c.type === "halt");
-    expect(halt).toBeDefined();
-    expect(halt).toMatchObject({ type: "halt", haltChunk: { reason: "no_recipe" } });
-    expect((halt as any).haltChunk.recovery_options).toHaveLength(3);
-    // Planner must NOT have been called.
-    expect(runCouncil).not.toHaveBeenCalled();
-  });
-});

package/src/product-loop/__tests__/sprint-self-verify.test.ts

@@ -1,77 +0,0 @@
-/**
- * src/product-loop/__tests__/sprint-self-verify.test.ts
- *
- * Tier 3 sprint-self-verify gate unit tests. Focus: gating logic (env flag,
- * watched-surface detection, summary parse). Does NOT actually spawn bun —
- * those paths are covered by the larger self-qa harness suite.
- */
-
-import { describe, expect, it } from "vitest";
-import { runSprintSelfVerify } from "../sprint-self-verify.js";
-
-describe("runSprintSelfVerify", () => {
-  const ORIG_CI = process.env["CI"];
-  const ORIG_NODE_ENV = process.env["NODE_ENV"];
-
-  function clearEnv() {
-    delete process.env["MUONROI_SPRINT_SELF_VERIFY"];
-    delete process.env["CI"];
-    delete process.env["NODE_ENV"];
-  }
-
-  function restoreEnv() {
-    if (ORIG_CI === undefined) delete process.env["CI"];
-    else process.env["CI"] = ORIG_CI;
-    if (ORIG_NODE_ENV === undefined) delete process.env["NODE_ENV"];
-    else process.env["NODE_ENV"] = ORIG_NODE_ENV;
-  }
-
-  it("default ON when no env flag set — fires past the gate", async () => {
-    clearEnv();
-    // baseRef=HEAD → empty diff → returns no-watched-changes (proves gate was passed).
-    const r = await runSprintSelfVerify({ repoRoot: process.cwd(), baseRef: "HEAD" });
-    expect(r.skipReason).not.toBe("disabled");
-    restoreEnv();
-  });
-
-  it("returns skipReason='disabled' when MUONROI_SPRINT_SELF_VERIFY=0", async () => {
-    clearEnv();
-    process.env["MUONROI_SPRINT_SELF_VERIFY"] = "0";
-    const r = await runSprintSelfVerify({ repoRoot: process.cwd() });
-    expect(r.ran).toBe(false);
-    expect(r.skipReason).toBe("disabled");
-    restoreEnv();
-  });
-
-  it("returns skipReason='disabled' when CI=true", async () => {
-    clearEnv();
-    process.env["CI"] = "true";
-    const r = await runSprintSelfVerify({ repoRoot: process.cwd() });
-    expect(r.ran).toBe(false);
-    expect(r.skipReason).toBe("disabled");
-    restoreEnv();
-  });
-
-  it("returns skipReason='no-watched-changes' when enabled and diff has no watched files", async () => {
-    clearEnv();
-    const r = await runSprintSelfVerify({
-      repoRoot: process.cwd(),
-      baseRef: "HEAD",
-    });
-    expect(r.ran).toBe(false);
-    expect(r.skipReason).toBe("no-watched-changes");
-    restoreEnv();
-  });
-
-  it("forceEnable overrides CI=true", async () => {
-    clearEnv();
-    process.env["CI"] = "true";
-    const r = await runSprintSelfVerify({
-      repoRoot: process.cwd(),
-      baseRef: "HEAD",
-      forceEnable: true,
-    });
-    expect(r.skipReason).not.toBe("disabled");
-    restoreEnv();
-  });
-});

package/src/product-loop/__tests__/sprint-store.test.ts

@@ -1,98 +0,0 @@
-/**
- * src/product-loop/__tests__/sprint-store.test.ts
- *
- * Unit tests for sprint-store.ts (read/write/setActiveSprint/markSprintDone).
- * Uses a real temp directory — atomicWriteJSON is tested end-to-end.
- */
-
-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 } from "vitest";
-import { markSprintDone, readSprintPlan, setActiveSprint, writeSprintPlan } from "../sprint-store.js";
-import type { Sprint, SprintPlan } from "../types.js";
-
-let tmpDir: string;
-
-function makePlan(overrides?: Partial<SprintPlan>): SprintPlan {
-  const sprints: Sprint[] = [
-    { id: "sprint-1", number: 1, goal: "Goal 1", itemIds: ["a"], status: "planned" },
-    { id: "sprint-2", number: 2, goal: "Goal 2", itemIds: ["b"], status: "planned" },
-  ];
-  return {
-    runId: "test-run",
-    sprints,
-    createdAtUtc: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(path.join(os.tmpdir(), "sprint-store-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-
-describe("sprint-store", () => {
-  it("returns null when sprint-plan.json does not exist", async () => {
-    const result = await readSprintPlan(tmpDir, "no-run");
-    expect(result).toBeNull();
-  });
-
-  it("write + read round-trip preserves all fields", async () => {
-    const plan = makePlan();
-    await writeSprintPlan(tmpDir, "test-run", plan);
-    const read = await readSprintPlan(tmpDir, "test-run");
-    expect(read).toEqual(plan);
-  });
-
-  it("setActiveSprint sets status=active and startedAtUtc", async () => {
-    const plan = makePlan();
-    await writeSprintPlan(tmpDir, "test-run", plan);
-
-    const updated = await setActiveSprint(tmpDir, "test-run", "sprint-1");
-    const s1 = updated.sprints.find((s) => s.id === "sprint-1")!;
-    expect(s1.status).toBe("active");
-    expect(s1.startedAtUtc).toBeTruthy();
-    expect(updated.activeSprintId).toBe("sprint-1");
-  });
-
-  it("setActiveSprint flips previous active sprint to done", async () => {
-    const plan = makePlan();
-    plan.sprints[0].status = "active";
-    plan.sprints[0].startedAtUtc = new Date().toISOString();
-    plan.activeSprintId = "sprint-1";
-    await writeSprintPlan(tmpDir, "test-run", plan);
-
-    const updated = await setActiveSprint(tmpDir, "test-run", "sprint-2");
-    const s1 = updated.sprints.find((s) => s.id === "sprint-1")!;
-    const s2 = updated.sprints.find((s) => s.id === "sprint-2")!;
-    expect(s1.status).toBe("done");
-    expect(s1.endedAtUtc).toBeTruthy();
-    expect(s2.status).toBe("active");
-    expect(updated.activeSprintId).toBe("sprint-2");
-  });
-
-  it("markSprintDone sets endedAtUtc and clears activeSprintId", async () => {
-    const plan = makePlan();
-    plan.sprints[0].status = "active";
-    plan.activeSprintId = "sprint-1";
-    await writeSprintPlan(tmpDir, "test-run", plan);
-
-    const updated = await markSprintDone(tmpDir, "test-run", "sprint-1");
-    const s1 = updated.sprints.find((s) => s.id === "sprint-1")!;
-    expect(s1.status).toBe("done");
-    expect(s1.endedAtUtc).toBeTruthy();
-    expect(updated.activeSprintId).toBeUndefined();
-  });
-
-  it("round-trip preserves string field types (no Date coercion)", async () => {
-    const plan = makePlan();
-    await writeSprintPlan(tmpDir, "test-run", plan);
-    const read = await readSprintPlan(tmpDir, "test-run");
-    expect(typeof read!.createdAtUtc).toBe("string");
-    expect(typeof read!.sprints[0].goal).toBe("string");
-  });
-});