muonroi-cli 1.4.0 → 1.4.1

package/src/product-loop/__tests__/context-policy.test.ts

@@ -1,280 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { buildSprintContext, CONTEXT_CAPS, digestSprintIntoPhase, handoffPhaseToNext } from "../context-policy.js";
-
-const fakeProject = `## Project (permanent)\n${"x".repeat(200)}`;
-
-describe("buildSprintContext (subsystem E)", () => {
-  it("renders all blocks in order under cap", () => {
-    const out = buildSprintContext({
-      projectContextFormatted: fakeProject,
-      customerDecisions: [],
-      phaseHistory: [],
-      currentPhase: {
-        id: "phase-1",
-        name: "n",
-        goal: "g",
-        successCriteria: ["A"],
-        scope: "s",
-        exitCondition: { type: "criteria-threshold", min: 0.8 },
-        dependsOn: [],
-        maxSprints: 2,
-      },
-      phaseDigest: [],
-      sprintTail: "## Sprint Tail\nrecent work",
-    });
-    expect(out.indexOf("Project")).toBeLessThan(out.indexOf("Customer Decisions"));
-    expect(out.indexOf("Customer Decisions")).toBeLessThan(out.indexOf("Phase History"));
-    expect(out.indexOf("Phase History")).toBeLessThan(out.indexOf("Current Phase"));
-    expect(out.indexOf("Current Phase")).toBeLessThan(out.indexOf("Phase Digest"));
-    expect(out.indexOf("Phase Digest")).toBeLessThan(out.indexOf("Sprint Tail"));
-  });
-
-  it("determinism: same inputs produce same output", () => {
-    const args = {
-      projectContextFormatted: fakeProject,
-      customerDecisions: [
-        { seq: 1, timestampUtc: "2026-05-13T00:00:00Z", phaseId: "phase-1", sprintN: 1, verdict: "accept" as const },
-      ],
-      phaseHistory: [],
-      currentPhase: {
-        id: "phase-1",
-        name: "n",
-        goal: "g",
-        successCriteria: ["A"],
-        scope: "s",
-        exitCondition: { type: "criteria-threshold" as const, min: 0.8 },
-        dependsOn: [],
-        maxSprints: 2,
-      },
-      phaseDigest: [{ sprintN: 1, timestampUtc: "2026-05-13T00:00:00Z", lessonText: "L" }],
-      sprintTail: "tail",
-    };
-    const a = buildSprintContext(args);
-    const b = buildSprintContext(args);
-    expect(a).toBe(b);
-  });
-
-  it("over cap with essentials fitting: trims sprintTail first", () => {
-    const tail = "T".repeat(20000);
-    const out = buildSprintContext({
-      projectContextFormatted: fakeProject,
-      customerDecisions: [],
-      phaseHistory: [],
-      currentPhase: {
-        id: "phase-1",
-        name: "n",
-        goal: "g",
-        successCriteria: ["A"],
-        scope: "s",
-        exitCondition: { type: "criteria-threshold", min: 0.8 },
-        dependsOn: [],
-        maxSprints: 2,
-      },
-      phaseDigest: [],
-      sprintTail: tail,
-    });
-    expect(out.length).toBeLessThanOrEqual(CONTEXT_CAPS.SPRINT_CONTEXT_BYTES + 200);
-    expect(out).toMatch(/\[…truncated \d+ bytes\]/);
-  });
-
-  it("project alone over cap → oversize marker", () => {
-    const huge = `## Project\n${"x".repeat(9000)}`;
-    const out = buildSprintContext({
-      projectContextFormatted: huge,
-      customerDecisions: [],
-      phaseHistory: [],
-      currentPhase: {
-        id: "phase-1",
-        name: "n",
-        goal: "g",
-        successCriteria: ["A"],
-        scope: "s",
-        exitCondition: { type: "criteria-threshold", min: 0.8 },
-        dependsOn: [],
-        maxSprints: 2,
-      },
-      phaseDigest: [],
-      sprintTail: "",
-    });
-    expect(out).toContain("[oversize:");
-    expect(out).not.toContain("Sprint Tail");
-  });
-
-  it("project + customer decisions together over cap → both intact + oversize marker", () => {
-    const proj = `## Project\n${"x".repeat(5000)}`;
-    const decisions = Array.from({ length: 50 }, (_, i) => ({
-      seq: i + 1,
-      timestampUtc: "2026-05-13T00:00:00Z",
-      phaseId: "phase-1",
-      sprintN: 1,
-      verdict: "reject" as const,
-      feedback: "Y".repeat(80),
-    }));
-    const out = buildSprintContext({
-      projectContextFormatted: proj,
-      customerDecisions: decisions,
-      phaseHistory: [],
-      currentPhase: {
-        id: "phase-1",
-        name: "n",
-        goal: "g",
-        successCriteria: ["A"],
-        scope: "s",
-        exitCondition: { type: "criteria-threshold", min: 0.8 },
-        dependsOn: [],
-        maxSprints: 2,
-      },
-      phaseDigest: [],
-      sprintTail: "tail",
-    });
-    expect(out).toContain("[oversize:");
-    for (let i = 1; i <= 50; i++) expect(out).toContain(`seq ${i}`);
-  });
-});
-
-describe("buildSprintContext truncOldestFirst history path (subsystem E)", () => {
-  const basePhase = {
-    id: "phase-1",
-    name: "n",
-    goal: "g",
-    successCriteria: ["A"],
-    scope: "s",
-    exitCondition: { type: "criteria-threshold" as const, min: 0.8 },
-    dependsOn: [],
-    maxSprints: 2,
-  };
-
-  it("large phaseHistory is truncated oldest-first within cap", () => {
-    const bigHistory = Array.from({ length: 100 }, (_, i) => ({
-      phaseId: `phase-${i}`,
-      exitedAtUtc: "2026-05-13T00:00:00Z",
-      exitSummary: "S".repeat(80),
-      sprintsExecuted: 1,
-      criteriaMetCount: 1,
-    }));
-    const out = buildSprintContext({
-      projectContextFormatted: fakeProject,
-      customerDecisions: [],
-      phaseHistory: bigHistory,
-      currentPhase: basePhase,
-      phaseDigest: [],
-      sprintTail: "",
-    });
-    // should contain truncation marker and be under total cap with some slack
-    expect(out).toMatch(/\[…truncated \d+ oldest entries\]/);
-    expect(Buffer.byteLength(out, "utf8")).toBeLessThanOrEqual(CONTEXT_CAPS.SPRINT_CONTEXT_BYTES + 300);
-  });
-
-  it("single-entry history that is oversized: truncOldestFirst keeps one entry", () => {
-    const singleBig = [
-      {
-        phaseId: "phase-big",
-        exitedAtUtc: "2026-05-13T00:00:00Z",
-        exitSummary: "X".repeat(9000),
-        sprintsExecuted: 1,
-        criteriaMetCount: 1,
-      },
-    ];
-    const out = buildSprintContext({
-      projectContextFormatted: fakeProject,
-      customerDecisions: [],
-      phaseHistory: singleBig,
-      currentPhase: basePhase,
-      phaseDigest: [],
-      sprintTail: "",
-    });
-    // single-entry path: while loop condition `lines.length > 1` exits early, entry stays
-    expect(out).toContain("phase-big");
-  });
-});
-
-describe("digestSprintIntoPhase (subsystem E)", () => {
-  it("appends entry when under cap", () => {
-    const out = digestSprintIntoPhase([], { sprintN: 1, timestampUtc: "t", lessonText: "L" });
-    expect(out).toHaveLength(1);
-  });
-
-  it("drops oldest when over cap, adds pruned marker", () => {
-    const big: any[] = [];
-    for (let i = 0; i < 200; i++) {
-      big.push({ sprintN: i, timestampUtc: "2026-05-13T00:00:00Z", lessonText: "X".repeat(40) });
-    }
-    const out = digestSprintIntoPhase(big, { sprintN: 999, timestampUtc: "t", lessonText: "new" });
-    expect(out.length).toBeLessThan(big.length + 1);
-    expect(out[0].lessonText).toMatch(/digest pruned/);
-    expect(out[out.length - 1].sprintN).toBe(999);
-  });
-
-  it("preserves order: newest stays last after pruning", () => {
-    const existing = [
-      { sprintN: 1, timestampUtc: "t", lessonText: "A".repeat(2000) },
-      { sprintN: 2, timestampUtc: "t", lessonText: "B".repeat(2000) },
-    ];
-    const out = digestSprintIntoPhase(existing, { sprintN: 3, timestampUtc: "t", lessonText: "C" });
-    expect(out[out.length - 1].sprintN).toBe(3);
-  });
-
-  it("single oversize entry dropped, adds marker + new entry", () => {
-    const huge = [{ sprintN: 1, timestampUtc: "t", lessonText: "X".repeat(5000) }];
-    const out = digestSprintIntoPhase(huge, { sprintN: 2, timestampUtc: "t", lessonText: "tiny" });
-    expect(out.length).toBe(2);
-    expect(out[0].sprintN).toBe(-1);
-    expect(out[0].lessonText).toMatch(/digest pruned/);
-    expect(out[1].sprintN).toBe(2);
-  });
-});
-
-describe("handoffPhaseToNext (subsystem E)", () => {
-  it("happy path uses leader summary truncated to 300 chars", async () => {
-    const leader = {
-      generate: vi.fn().mockResolvedValue({ content: "All good carry over X.".repeat(50), costUsd: 0.05 }),
-    };
-    const out = await handoffPhaseToNext({
-      phaseId: "phase-1",
-      sprintsExecuted: 2,
-      criteriaMet: 3,
-      totalCriteria: 3,
-      leader,
-      capUsd: 10,
-      remainingUsd: 1,
-      backoffDelays: [1, 1, 1],
-    });
-    expect(out.exitSummary.length).toBeLessThanOrEqual(300);
-    expect(out.usedFallback).toBe(false);
-  });
-
-  it("falls back to deterministic when remainingUsd below floor", async () => {
-    const leader = { generate: vi.fn() };
-    const out = await handoffPhaseToNext({
-      phaseId: "phase-1",
-      sprintsExecuted: 2,
-      criteriaMet: 1,
-      totalCriteria: 3,
-      leader,
-      capUsd: 10,
-      remainingUsd: 0.01,
-      backoffDelays: [1, 1, 1],
-    });
-    expect(leader.generate).not.toHaveBeenCalled();
-    expect(out.usedFallback).toBe(true);
-    expect(out.exitSummary).toContain("phase-1");
-    expect(out.exitSummary).toContain("1/3");
-  });
-
-  it("falls back on 3 429s", async () => {
-    const err: any = new Error("429");
-    err.status = 429;
-    const leader = { generate: vi.fn().mockRejectedValue(err) };
-    const out = await handoffPhaseToNext({
-      phaseId: "phase-2",
-      sprintsExecuted: 5,
-      criteriaMet: 2,
-      totalCriteria: 2,
-      leader,
-      capUsd: 10,
-      remainingUsd: 1,
-      backoffDelays: [1, 1, 1],
-    });
-    expect(out.usedFallback).toBe(true);
-  });
-});

package/src/product-loop/__tests__/cost-preview.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DEFAULT_HEURISTIC, formatCostPreview, previewRunCost } from "../cost-preview.js";
-
-describe("previewRunCost", () => {
-  it("uses cached_input price when model has one (DeepSeek flash)", () => {
-    const p = previewRunCost({
-      sessionModelId: "deepseek-v4-flash",
-      maxSprints: 8,
-      capUsd: 50,
-    });
-    expect(p.pricingKnown).toBe(true);
-    expect(p.cachedInputAvailable).toBe(true);
-    expect(p.estPerSprintUsd).toBeGreaterThan(0);
-    expect(p.estTotalUsd).toBeCloseTo(p.estPerSprintUsd * 8, 5);
-    // With 70% cache hit at $0.027/M and miss at $0.27/M plus $1.10/M output,
-    // a single sprint should be well under $1.
-    expect(p.estPerSprintUsd).toBeLessThan(1);
-  });
-
-  it("flags willExceedCap when total > cap and recommends fewer sprints", () => {
-    const p = previewRunCost({
-      sessionModelId: "claude-3-opus-latest",
-      maxSprints: 100,
-      capUsd: 5,
-    });
-    expect(p.willExceedCap).toBe(true);
-    expect(p.recommendedMaxSprints).toBeLessThan(100);
-    expect(p.recommendedMaxSprints).toBeGreaterThanOrEqual(1);
-  });
-
-  it("returns pricingKnown=false for unknown model", () => {
-    const p = previewRunCost({
-      sessionModelId: "nonexistent-model-9999",
-      maxSprints: 8,
-      capUsd: 50,
-    });
-    expect(p.pricingKnown).toBe(false);
-    expect(p.estPerSprintUsd).toBe(0);
-    expect(p.estTotalUsd).toBe(0);
-    expect(p.willExceedCap).toBe(false);
-  });
-
-  it("ollama wildcard yields zero cost", () => {
-    const p = previewRunCost({
-      sessionModelId: "any-local-model",
-      maxSprints: 8,
-      capUsd: 50,
-    });
-    // ollama is provider-detected based on model id prefix — unknown id falls
-    // through to anthropic default. Verify the explicit ollama-prefixed case.
-    void p;
-
-    // Direct check for ollama "*" pricing via deepseek path is meaningless;
-    // instead verify when pricing exists, hit rate scales cost down.
-    const cached = previewRunCost({
-      sessionModelId: "gpt-4o-mini",
-      maxSprints: 4,
-      capUsd: 50,
-    });
-    const uncachedHeuristic = { ...DEFAULT_HEURISTIC, cacheHitRate: 0 };
-    const uncached = previewRunCost({
-      sessionModelId: "gpt-4o-mini",
-      maxSprints: 4,
-      capUsd: 50,
-      heuristic: uncachedHeuristic,
-    });
-    expect(cached.estPerSprintUsd).toBeLessThan(uncached.estPerSprintUsd);
-  });
-
-  it("formatCostPreview renders fits-cap notice on safe runs", () => {
-    const out = formatCostPreview({
-      modelId: "deepseek-v4-flash",
-      provider: "deepseek",
-      pricingKnown: true,
-      cachedInputAvailable: true,
-      estPerSprintUsd: 0.05,
-      estTotalUsd: 0.4,
-      capUsd: 50,
-      willExceedCap: false,
-      recommendedMaxSprints: 8,
-    });
-    expect(out).toContain("Cost preview");
-    expect(out).toContain("$0.05");
-    expect(out).toMatch(/fits the cap/i);
-    expect(out).toContain("prompt-cache priced");
-  });
-
-  it("formatCostPreview renders exceed-cap warning + recommendation", () => {
-    const out = formatCostPreview({
-      modelId: "claude-3-opus-latest",
-      provider: "anthropic",
-      pricingKnown: true,
-      cachedInputAvailable: true,
-      estPerSprintUsd: 5,
-      estTotalUsd: 40,
-      capUsd: 10,
-      willExceedCap: true,
-      recommendedMaxSprints: 2,
-    });
-    expect(out).toMatch(/exceeds.*cap/i);
-    expect(out).toContain("--max-sprints 2");
-  });
-
-  it("formatCostPreview surfaces unknown-pricing notice", () => {
-    const out = formatCostPreview({
-      modelId: "mystery-model",
-      provider: "unknown",
-      pricingKnown: false,
-      cachedInputAvailable: false,
-      estPerSprintUsd: 0,
-      estTotalUsd: 0,
-      capUsd: 50,
-      willExceedCap: false,
-      recommendedMaxSprints: 8,
-    });
-    expect(out).toMatch(/pricing not known/i);
-  });
-});

package/src/product-loop/__tests__/cost-scoper.test.ts

@@ -1,76 +0,0 @@
-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 * as ledger from "../../usage/ledger.js";
-import * as productLedger from "../../usage/product-ledger.js";
-import { CapBreachError } from "../../usage/types.js";
-import { reserveForProduct } from "../cost-scoper.js";
-
-const TEST_HOME = path.join(os.tmpdir(), `muonroi-test-${Math.random().toString(36).slice(2)}`);
-
-describe("cost-scoper", () => {
-  beforeEach(async () => {
-    await fs.mkdir(TEST_HOME, { recursive: true });
-    vi.restoreAllMocks();
-  });
-
-  afterEach(async () => {
-    await fs.rm(TEST_HOME, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-  });
-
-  it("issues reservation when both caps are fine", async () => {
-    vi.spyOn(productLedger, "getProductSpentUsd").mockResolvedValue(0.1);
-    const reserveSpy = vi.spyOn(ledger, "reserve").mockResolvedValue({
-      id: "r1",
-      model: "claude-3-5-sonnet-latest",
-      provider: "anthropic",
-      projected_usd: 0.05,
-      est_input_tokens: 100,
-      est_output_tokens: 100,
-      createdAtMs: Date.now(),
-    });
-
-    const result = await reserveForProduct(
-      { provider: "anthropic", model: "claude-3-5-sonnet-latest", estInputTokens: 100, estOutputTokens: 100 },
-      "run-1",
-      1.0,
-      TEST_HOME,
-    );
-
-    expect(result).not.toBeInstanceOf(CapBreachError);
-    if (!(result instanceof CapBreachError)) {
-      expect(result.productRunId).toBe("run-1");
-    }
-    expect(reserveSpy).toHaveBeenCalled();
-  });
-
-  it("blocks when per-product cap is hit", async () => {
-    vi.spyOn(productLedger, "getProductSpentUsd").mockResolvedValue(0.95);
-    const reserveSpy = vi.spyOn(ledger, "reserve");
-
-    const result = await reserveForProduct(
-      { provider: "anthropic", model: "claude-3-5-sonnet-latest", estInputTokens: 10000, estOutputTokens: 10000 },
-      "run-1",
-      1.0,
-      TEST_HOME,
-    );
-
-    expect(result instanceof CapBreachError || (result as any).name === "CapBreachError").toBe(true);
-    expect(reserveSpy).not.toHaveBeenCalled();
-  });
-
-  it("blocks when monthly cap is hit", async () => {
-    vi.spyOn(productLedger, "getProductSpentUsd").mockResolvedValue(0.1);
-    vi.spyOn(ledger, "reserve").mockResolvedValue(new CapBreachError(14, 0, 2, 15));
-
-    const result = await reserveForProduct(
-      { provider: "anthropic", model: "claude-3-5-sonnet-latest", estInputTokens: 100, estOutputTokens: 100 },
-      "run-1",
-      1.0,
-      TEST_HOME,
-    );
-
-    expect(result instanceof CapBreachError || (result as any).name === "CapBreachError").toBe(true);
-  });
-});

package/src/product-loop/__tests__/cross-run-memory.test.ts

@@ -1,195 +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 type { CouncilLLM } from "../../council/types.js";
-import { writeManifest } from "../artifact-io.js";
-import { buildPriorContext, discoverPriorRuns, formatPriorContextForPrompt } from "../cross-run-memory.js";
-
-function makeStubLLM(generated: string): CouncilLLM {
-  return {
-    generate: vi.fn().mockResolvedValue(generated),
-    debate: vi.fn(),
-    research: vi.fn(),
-    generateObject: vi.fn(),
-  } as unknown as CouncilLLM;
-}
-
-async function seedRun(
-  flowDir: string,
-  runId: string,
-  idea: string,
-  opts: {
-    pass?: boolean;
-    failedCondition?: import("../types.js").DoneCondition;
-    daysOld?: number;
-    memories?: Record<string, string>;
-  } = {},
-) {
-  const createdAt = new Date(Date.now() - (opts.daysOld ?? 0) * 24 * 60 * 60 * 1000);
-  await writeManifest(flowDir, runId, {
-    idea,
-    capUsd: 50,
-    maxSprints: 8,
-    doneThreshold: 0.9,
-    createdAt,
-    verdict:
-      opts.pass !== undefined
-        ? { pass: opts.pass, score: opts.pass ? 0.92 : 0.5, failedCondition: opts.failedCondition }
-        : undefined,
-  });
-  if (opts.memories) {
-    const memoryDir = path.join(flowDir, "runs", runId, "memory");
-    await fs.mkdir(memoryDir, { recursive: true });
-    for (const [slot, content] of Object.entries(opts.memories)) {
-      await fs.writeFile(path.join(memoryDir, `${slot}.md`), content);
-    }
-  }
-}
-
-describe("cross-run-memory (P5)", () => {
-  let flowDir: string;
-
-  beforeEach(async () => {
-    flowDir = path.join(os.tmpdir(), `xrm-test-${Math.random().toString(36).slice(2)}`);
-    await fs.mkdir(flowDir, { recursive: true });
-  });
-
-  it("returns empty when no prior runs exist", async () => {
-    const runs = await discoverPriorRuns(flowDir, "current", "anything");
-    expect(runs).toEqual([]);
-  });
-
-  it("excludes current run from results", async () => {
-    await seedRun(flowDir, "current", "build a pdf translator extension");
-    const runs = await discoverPriorRuns(flowDir, "current", "build a pdf translator extension");
-    expect(runs).toEqual([]);
-  });
-
-  it("filters out low-similarity runs", async () => {
-    await seedRun(flowDir, "prior", "build a discord music bot");
-    const runs = await discoverPriorRuns(flowDir, "current", "design a database migration tool");
-    expect(runs.length).toBe(0);
-  });
-
-  it("keeps high-similarity runs and ranks by weight", async () => {
-    await seedRun(flowDir, "prior-recent", "pdf translator browser extension", { pass: true });
-    await seedRun(flowDir, "prior-old", "pdf translator chrome extension", {
-      pass: false,
-      failedCondition: "engineering_floor",
-      daysOld: 60,
-    });
-    const runs = await discoverPriorRuns(flowDir, "current", "pdf translator extension for brave browser");
-    expect(runs.length).toBe(2);
-    expect(runs[0].runId).toBe("prior-recent");
-    expect(runs[0].weight).toBeGreaterThan(runs[1].weight);
-    expect(runs[1].recency).toBeLessThan(runs[0].recency);
-  });
-
-  it("loads per-role memory files for qualifying runs", async () => {
-    await seedRun(flowDir, "prior", "pdf translator extension", {
-      pass: true,
-      memories: {
-        architect: "### Sprint 1\nChose Manifest V3 with content scripts.",
-        tester: "### Sprint 1\nUsed Playwright for e2e tests.",
-      },
-    });
-    const runs = await discoverPriorRuns(flowDir, "current", "pdf translator extension v2");
-    expect(runs.length).toBe(1);
-    expect(runs[0].memories.has("architect")).toBe(true);
-    expect(runs[0].memories.get("architect")).toContain("Manifest V3");
-  });
-
-  it("buildPriorContext returns empty digest when optOut=true", async () => {
-    await seedRun(flowDir, "prior", "pdf translator extension", { pass: true });
-    const llm = makeStubLLM("should not be called");
-    const result = await buildPriorContext({
-      flowDir,
-      runId: "current",
-      idea: "pdf translator extension v2",
-      leaderModelId: "leader-model",
-      llm,
-      optOut: true,
-    });
-    expect(result.digest).toBe("");
-    expect(result.runs).toEqual([]);
-    expect(llm.generate).not.toHaveBeenCalled();
-  });
-
-  it("buildPriorContext always returns empty digest (P1.5: leader LLM synthesis removed)", async () => {
-    await seedRun(flowDir, "prior", "pdf translator extension", {
-      pass: true,
-      memories: { architect: "Chose Manifest V3." },
-    });
-    const llm = makeStubLLM("should not be called");
-    const result = await buildPriorContext({
-      flowDir,
-      runId: "current",
-      idea: "pdf translator extension v2",
-      leaderModelId: "leader-model",
-      llm,
-    });
-    // P1.5: digest synthesis was removed — digest is always "" regardless of runs
-    expect(result.digest).toBe("");
-    expect(result.runs.length).toBe(1);
-    // leader LLM must NOT be called — PIL Layer 3 handles injection per-call
-    expect(llm.generate).not.toHaveBeenCalled();
-
-    const stateFile = path.join(flowDir, "runs", "current", "state.md");
-    const state = await fs.readFile(stateFile, "utf8");
-    // P1.5: section is now "EE Injections (Layer 3)" instead of "Prior Decisions Context"
-    expect(state).toContain("EE Injections (Layer 3)");
-  });
-
-  it("buildPriorContext persists no-injections fallback when nothing matches", async () => {
-    await seedRun(flowDir, "prior", "completely unrelated topic", { pass: true });
-    const llm = makeStubLLM("should not be called");
-    const result = await buildPriorContext({
-      flowDir,
-      runId: "current",
-      idea: "totally different idea here",
-      leaderModelId: "leader-model",
-      llm,
-    });
-    expect(result.runs.length).toBe(0);
-    expect(result.digest).toBe("");
-    expect(llm.generate).not.toHaveBeenCalled();
-    const stateFile = path.join(flowDir, "runs", "current", "state.md");
-    const state = await fs.readFile(stateFile, "utf8");
-    // P1.5: fallback text when no DB rows found
-    expect(state).toContain("no EE injections recorded yet");
-  });
-
-  it("formatPriorContextForPrompt returns empty for empty digest", () => {
-    expect(formatPriorContextForPrompt("")).toBe("");
-    expect(formatPriorContextForPrompt("   ")).toBe("");
-  });
-
-  it("formatPriorContextForPrompt wraps non-empty digest with header", () => {
-    const out = formatPriorContextForPrompt("- decision 1\n- decision 2");
-    expect(out).toContain("Prior Decisions Context");
-    expect(out).toContain("decision 1");
-    expect(out).toContain("decision 2");
-  });
-
-  it("LLM is never called — digest synthesis removed in P1.5", async () => {
-    await seedRun(flowDir, "prior", "pdf translator extension", { pass: true });
-    const llm = {
-      generate: vi.fn().mockRejectedValue(new Error("upstream 500")),
-      debate: vi.fn(),
-      research: vi.fn(),
-      generateObject: vi.fn(),
-    } as unknown as CouncilLLM;
-    const result = await buildPriorContext({
-      flowDir,
-      runId: "current",
-      idea: "pdf translator extension v2",
-      leaderModelId: "leader-model",
-      llm,
-    });
-    // P1.5: no LLM call — always empty digest, runs still discovered
-    expect(result.digest).toBe("");
-    expect(result.runs.length).toBe(1);
-    expect(llm.generate).not.toHaveBeenCalled();
-  });
-});