muonroi-cli 1.4.0 → 1.5.0

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

@@ -1,315 +0,0 @@
-/**
- * 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";
-import type { ProductSpec, RoleSlot } from "../types.js";
-
-const NO_ROLES = new Map<RoleSlot, { modelId: string; provider: string; tier?: string }>();
-
-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(),
-  };
-}
-
-async function drainWithResult<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 as T);
-    }
-  } catch (error) {
-    return { chunks, result: undefined, error };
-  }
-}
-
-// ── Common beforeEach ──────────────────────────────────────────────────────
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  (CB3_verifyBlank as ReturnType<typeof vi.fn>).mockReturnValue({ halt: false });
-  (evaluateDoneGate as ReturnType<typeof vi.fn>).mockResolvedValue({ pass: true, score: 1.0 });
-  (runVerifyOrchestration as ReturnType<typeof vi.fn>).mockResolvedValue({
-    success: true,
-    output: "VERIFY_PASS\n",
-    verifyRecipe: { testCommands: ["npm test"], coverage: 80, shellInitCommands: [] },
-  });
-});
-
-afterEach(() => {
-  delete (globalThis as Record<string, unknown>).__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 as ReturnType<typeof vi.fn>).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 as never, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-
-    // All 4 sprint_stage "active" events must fire
-    const phaseActives = chunks
-      .filter(
-        (c) =>
-          (c as unknown as Record<string, unknown>).type === "council_phase" &&
-          ((c as unknown as Record<string, unknown>).councilPhase as Record<string, unknown>)?.kind ===
-            "sprint_stage" &&
-          ((c as unknown as Record<string, unknown>).councilPhase as Record<string, unknown>)?.state === "active",
-      )
-      .map(
-        (c) => ((c as unknown as Record<string, unknown>).councilPhase as Record<string, unknown>).phaseId as string,
-      );
-
-    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 as any)[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 as ReturnType<typeof vi.fn>).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 as never, 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 as unknown as Record<string, unknown>).type === "council_phase" &&
-          ((c as unknown as Record<string, unknown>).councilPhase as Record<string, unknown>)?.phaseId ===
-            "sprint-1-implementation",
-      )
-      .map((c) => ((c as unknown as Record<string, unknown>).councilPhase as Record<string, unknown>).state as string);
-
-    // 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 as ReturnType<typeof vi.fn>).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 as never, productSpec: makeSpec(), roleAssignments: NO_ROLES, history: [] }),
-    );
-
-    const implPhaseChunks = chunks
-      .filter(
-        (c) =>
-          (c as unknown as Record<string, unknown>).type === "council_phase" &&
-          ((c as unknown as Record<string, unknown>).councilPhase as Record<string, unknown>)?.phaseId ===
-            "sprint-1-implementation",
-      )
-      .map((c) => ((c as unknown as Record<string, unknown>).councilPhase as Record<string, unknown>).state as string);
-
-    expect(implPhaseChunks).toContain("active");
-    expect(implPhaseChunks).toContain("done");
-  });
-});

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

@@ -1,189 +0,0 @@
-/**
- * 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<T, R>(gen: AsyncGenerator<T, R, unknown>): Promise<void> {
-  while (true) {
-    const step = await gen.next();
-    if (step.done) break;
-  }
-}
-
-function makeOpts(flowDir: string) {
-  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: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "phase-a2-test-"));
-    vi.clearAllMocks();
-
-    // Driver returns approved
-    (runLoopDriver as ReturnType<typeof vi.fn>).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 as ReturnType<typeof vi.fn>).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) as never));
-
-    // Look for backlog.json + sprint-plan.json in .planning/runs/<runId>/
-    const runsDir = path.join(tmpDir, "runs");
-    const runDirs = await fs.readdir(runsDir).catch(() => [] as string[]);
-    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) as never));
-
-    const runsDir = path.join(tmpDir, "runs");
-    const runDirs1 = await fs.readdir(runsDir).catch(() => [] as string[]);
-    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 as never));
-
-    // backlog.json mtime must be unchanged (idempotent — not re-written)
-    const backlogStat2 = await fs.stat(backlogPath).catch(() => null);
-    expect(backlogStat2?.mtimeMs).toBe(backlogStat1?.mtimeMs);
-  });
-});

package/src/product-loop/__tests__/phase-budget.test.ts

@@ -1,172 +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 { PHASE_HINTS, recordPhaseEnd, recordPhaseStart, renderBudgetSummary } from "../phase-budget.js";
-
-vi.mock("../../usage/product-ledger.js", () => ({
-  getProductSpentUsd: vi.fn(),
-}));
-
-import { getProductSpentUsd } from "../../usage/product-ledger.js";
-
-const mockGetSpent = getProductSpentUsd as ReturnType<typeof vi.fn>;
-
-describe("phase-budget (P7)", () => {
-  let flowDir: string;
-  const runId = "run-test";
-
-  beforeEach(async () => {
-    flowDir = path.join(os.tmpdir(), `budget-${Math.random().toString(36).slice(2)}`);
-    await fs.mkdir(flowDir, { recursive: true });
-    mockGetSpent.mockReset();
-  });
-
-  it("old hints (discover/gather/research/scoping/sprint) sum correctly", () => {
-    const oldTotal =
-      PHASE_HINTS.discover + PHASE_HINTS.gather + PHASE_HINTS.research + PHASE_HINTS.scoping + PHASE_HINTS.sprint;
-    expect(oldTotal).toBeCloseTo(0.83, 2);
-  });
-
-  it("returns null warning when phase stays within hint", async () => {
-    mockGetSpent.mockResolvedValueOnce(0).mockResolvedValueOnce(1.5);
-    const marker = await recordPhaseStart({ flowDir, runId, phase: "research" });
-    // research hint = 0.35 * 50 = 17.5; spent 1.5 << 17.5*1.5
-    const warning = await recordPhaseEnd({ flowDir, runId, capUsd: 50, marker });
-    expect(warning).toBeNull();
-  });
-
-  it("emits warning when spent exceeds hint by >50%", async () => {
-    // discover hint = 0.05 * 50 = 2.5; threshold = 3.75; spent = 5.0 > 3.75
-    mockGetSpent.mockResolvedValueOnce(0).mockResolvedValueOnce(5.0);
-    const marker = await recordPhaseStart({ flowDir, runId, phase: "discover" });
-    const warning = await recordPhaseEnd({ flowDir, runId, capUsd: 50, marker });
-    expect(warning).not.toBeNull();
-    expect(warning).toContain("discover");
-    expect(warning).toContain("over");
-  });
-
-  it("does not warn when capUsd is zero or negative", async () => {
-    mockGetSpent.mockResolvedValueOnce(0).mockResolvedValueOnce(100);
-    const marker = await recordPhaseStart({ flowDir, runId, phase: "research" });
-    const warning = await recordPhaseEnd({ flowDir, runId, capUsd: 0, marker });
-    expect(warning).toBeNull();
-  });
-
-  it("persists per-phase records to state.md", async () => {
-    mockGetSpent.mockResolvedValueOnce(0).mockResolvedValueOnce(1.0);
-    const marker = await recordPhaseStart({ flowDir, runId, phase: "discover" });
-    await recordPhaseEnd({ flowDir, runId, capUsd: 50, marker });
-    const stateFile = path.join(flowDir, "runs", runId, "state.md");
-    const content = await fs.readFile(stateFile, "utf8");
-    expect(content).toContain("Phase Budget");
-    expect(content).toContain("discover");
-  });
-
-  it("appends multiple phase records over a run", async () => {
-    mockGetSpent
-      .mockResolvedValueOnce(0)
-      .mockResolvedValueOnce(0.5) // discover
-      .mockResolvedValueOnce(0.5)
-      .mockResolvedValueOnce(2.0); // gather
-    const m1 = await recordPhaseStart({ flowDir, runId, phase: "discover" });
-    await recordPhaseEnd({ flowDir, runId, capUsd: 50, marker: m1 });
-    const m2 = await recordPhaseStart({ flowDir, runId, phase: "gather" });
-    await recordPhaseEnd({ flowDir, runId, capUsd: 50, marker: m2 });
-
-    const summary = await renderBudgetSummary(flowDir, runId);
-    expect(summary).toContain("discover");
-    expect(summary).toContain("gather");
-    expect(summary).toContain("Cap: $50.00");
-  });
-
-  it("renderBudgetSummary returns placeholder when no data", async () => {
-    const summary = await renderBudgetSummary(flowDir, "never-existed");
-    expect(summary).toContain("no phase budget data");
-  });
-
-  it("flags [OVER] in summary when phase exceeded hint", async () => {
-    mockGetSpent.mockResolvedValueOnce(0).mockResolvedValueOnce(10.0);
-    const marker = await recordPhaseStart({ flowDir, runId, phase: "discover" });
-    await recordPhaseEnd({ flowDir, runId, capUsd: 50, marker });
-    const summary = await renderBudgetSummary(flowDir, runId);
-    expect(summary).toContain("[OVER]");
-  });
-
-  it("clamps negative phase spend to zero (ledger anomaly safety)", async () => {
-    mockGetSpent.mockResolvedValueOnce(10).mockResolvedValueOnce(5); // end < start
-    const marker = await recordPhaseStart({ flowDir, runId, phase: "research" });
-    const warning = await recordPhaseEnd({ flowDir, runId, capUsd: 50, marker });
-    expect(warning).toBeNull();
-    const summary = await renderBudgetSummary(flowDir, runId);
-    expect(summary).toContain("$0.000");
-  });
-});
-
-describe("phase-budget v2 (subsystem E)", () => {
-  it("PHASE_HINTS includes new keys planning/review/retro/standup summing to 0.98 (before verdict)", () => {
-    const total =
-      PHASE_HINTS.discover +
-      PHASE_HINTS.gather +
-      PHASE_HINTS.research +
-      PHASE_HINTS.scoping +
-      PHASE_HINTS.sprint +
-      (PHASE_HINTS as any).planning +
-      (PHASE_HINTS as any).review +
-      (PHASE_HINTS as any).retro +
-      (PHASE_HINTS as any).standup;
-    expect(total).toBeCloseTo(0.98, 2);
-  });
-
-  it("recordPhaseStart accepts new phase 'planning'", async () => {
-    const flowDir = path.join(os.tmpdir(), `budget-v2-${Math.random().toString(36).slice(2)}`);
-    await fs.mkdir(flowDir, { recursive: true });
-    mockGetSpent.mockResolvedValueOnce(0);
-    const marker = await recordPhaseStart({ flowDir, runId: "r1", phase: "planning" as any });
-    expect(marker.phase).toBe("planning");
-  });
-
-  it("on resume, persisted records without schemaVersion are skipped", async () => {
-    const flowDir = path.join(os.tmpdir(), `budget-v1legacy-${Math.random().toString(36).slice(2)}`);
-    const runId = "r-legacy";
-    await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    const legacy = {
-      capUsd: 50,
-      records: [{ phase: "research", startUsd: 0, endUsd: 5, spentUsd: 5, hintUsd: 10, warnedOverBudget: false }],
-    };
-    const statePath = path.join(flowDir, "runs", runId, "state.md");
-    await fs.writeFile(statePath, `## Phase Budget\n\n${JSON.stringify(legacy)}\n`);
-    const summary = await renderBudgetSummary(flowDir, runId);
-    expect(summary).toContain("no phase budget data");
-  });
-});
-
-describe("phase-budget verdict bucket (subsystem F)", () => {
-  it("PHASE_HINTS includes 'verdict' bucket, sum still 1.0", () => {
-    const total =
-      PHASE_HINTS.discover +
-      PHASE_HINTS.gather +
-      PHASE_HINTS.research +
-      PHASE_HINTS.scoping +
-      PHASE_HINTS.sprint +
-      PHASE_HINTS.planning +
-      PHASE_HINTS.review +
-      PHASE_HINTS.retro +
-      PHASE_HINTS.standup +
-      (PHASE_HINTS as any).verdict;
-    expect(total).toBeCloseTo(1.0, 2);
-  });
-
-  it("sprint hint reduced to 0.28 to make room for verdict 0.02", () => {
-    expect(PHASE_HINTS.sprint).toBe(0.28);
-    expect((PHASE_HINTS as any).verdict).toBe(0.02);
-  });
-
-  it("recordPhaseStart accepts new phase 'verdict'", async () => {
-    const flowDir = path.join(os.tmpdir(), `budget-verdict-${Math.random().toString(36).slice(2)}`);
-    await fs.mkdir(flowDir, { recursive: true });
-    mockGetSpent.mockResolvedValueOnce(0);
-    const marker = await recordPhaseStart({ flowDir, runId: "rv", phase: "verdict" as any });
-    expect(marker.phase).toBe("verdict");
-  });
-});