muonroi-cli 1.4.0 → 1.4.1

package/src/product-loop/__tests__/discovery-ecosystem.test.ts

@@ -1,246 +0,0 @@
-/**
- * Tests for the ecosystem-prompt module.
- *
- * Goal: every Council/discovery prompt path must frame answers within the
- * Muonroi ecosystem (BB, Muonroi.* templates, @muonroi/agent-harness-*) by
- * default. Opt-out toggles ALL paths off in one switch.
- */
-
-import * as fsMod from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { describe, expect, it, vi } from "vitest";
-import {
-  buildEcosystemDebateContext,
-  buildEcosystemPreamble,
-  buildEcosystemResearchSeed,
-  isEcosystemBiasEnabled,
-  shouldApplyEcosystemBias,
-} from "../discovery-ecosystem.js";
-
-// Stub the user-settings reader so tests don't depend on a live config file.
-vi.mock("../../utils/settings.js", async (orig) => {
-  const real: Record<string, unknown> = await orig();
-  return {
-    ...real,
-    loadUserSettings: vi.fn(() => ({})),
-  };
-});
-
-import { loadUserSettings } from "../../utils/settings.js";
-
-describe("buildEcosystemPreamble", () => {
-  it("names the three Muonroi templates", () => {
-    const text = buildEcosystemPreamble();
-    expect(text).toContain("Muonroi.BaseTemplate");
-    expect(text).toContain("Muonroi.Microservices.Template");
-    expect(text).toContain("Muonroi.Modular.Template");
-  });
-
-  it("mentions muonroi-building-block (BB) as the default building blocks", () => {
-    const text = buildEcosystemPreamble();
-    expect(text).toContain("muonroi-building-block");
-    expect(text).toContain("BB");
-  });
-
-  it("lists both React + Angular agent-harness adapters", () => {
-    const text = buildEcosystemPreamble();
-    expect(text).toContain("@muonroi/agent-harness-react");
-    expect(text).toContain("@muonroi/agent-harness-angular");
-  });
-
-  it("explicitly allows opt-out only when the user names a non-ecosystem stack", () => {
-    const text = buildEcosystemPreamble();
-    expect(text.toLowerCase()).toContain("explicitly opts out");
-  });
-
-  it("defaults backend stack to .NET 9", () => {
-    const text = buildEcosystemPreamble();
-    expect(text).toContain(".NET 9");
-  });
-});
-
-describe("buildEcosystemDebateContext", () => {
-  it("frames stances around optimal use of existing packages, not greenfield", () => {
-    const text = buildEcosystemDebateContext();
-    expect(text.toLowerCase()).toContain("optimal use");
-    expect(text.toLowerCase()).toContain("avoid stances that propose greenfield reinventions");
-  });
-
-  it("names BB + the three templates so the leader has concrete options", () => {
-    const text = buildEcosystemDebateContext();
-    expect(text).toContain("muonroi-building-block");
-    expect(text).toContain("Muonroi.BaseTemplate");
-    expect(text).toContain("Muonroi.Microservices.Template");
-    expect(text).toContain("Muonroi.Modular.Template");
-  });
-
-  it("mentions Authorization + Infrastructure + Queries/Commands as modular boundaries", () => {
-    const text = buildEcosystemDebateContext();
-    expect(text).toContain("Authorization");
-    expect(text).toContain("Infrastructure");
-    expect(text).toContain("Queries");
-    expect(text).toContain("Commands");
-  });
-});
-
-describe("buildEcosystemResearchSeed", () => {
-  it("Researcher lens prioritizes muonroi-docs MCP over web search", () => {
-    const seed = buildEcosystemResearchSeed();
-    expect(seed.researcherLens).toContain("muonroi-docs");
-    expect(seed.researcherLens).toContain("docs_search");
-    expect(seed.researcherLens.toLowerCase()).toContain("first");
-    expect(seed.researcherLens.toLowerCase()).toContain("fall back to web");
-  });
-
-  it("Architect lens forbids greenfield reinventions where a package exists", () => {
-    const seed = buildEcosystemResearchSeed();
-    expect(seed.architectLens.toLowerCase()).toContain("existing");
-    expect(seed.architectLens.toLowerCase()).toContain("greenfield code is allowed only");
-  });
-
-  it("Skeptic lens demands evidence from muonroi-docs before accepting feature claims", () => {
-    const seed = buildEcosystemResearchSeed();
-    expect(seed.skepticLens).toContain("muonroi-docs");
-    expect(seed.skepticLens.toLowerCase()).toContain("evidence");
-    expect(seed.skepticLens.toLowerCase()).toContain("reinvention");
-  });
-});
-
-describe("isEcosystemBiasEnabled", () => {
-  it("defaults to true when discoveryEcosystemBias is undefined", () => {
-    (loadUserSettings as unknown as ReturnType<typeof vi.fn>).mockReturnValueOnce({});
-    expect(isEcosystemBiasEnabled()).toBe(true);
-  });
-
-  it("returns true when discoveryEcosystemBias === true", () => {
-    (loadUserSettings as unknown as ReturnType<typeof vi.fn>).mockReturnValueOnce({
-      discoveryEcosystemBias: true,
-    });
-    expect(isEcosystemBiasEnabled()).toBe(true);
-  });
-
-  it("returns false only when discoveryEcosystemBias === false", () => {
-    (loadUserSettings as unknown as ReturnType<typeof vi.fn>).mockReturnValueOnce({
-      discoveryEcosystemBias: false,
-    });
-    expect(isEcosystemBiasEnabled()).toBe(false);
-  });
-
-  it("fails OPEN when settings read throws", () => {
-    (loadUserSettings as unknown as ReturnType<typeof vi.fn>).mockImplementationOnce(() => {
-      throw new Error("disk error");
-    });
-    expect(isEcosystemBiasEnabled()).toBe(true);
-  });
-});
-
-describe("shouldApplyEcosystemBias", () => {
-  const setSetting = (value: unknown) =>
-    (loadUserSettings as unknown as ReturnType<typeof vi.fn>).mockReturnValueOnce(value as Record<string, unknown>);
-
-  it("explicit opt-out short-circuits regardless of classification", () => {
-    setSetting({ discoveryEcosystemBias: false });
-    expect(shouldApplyEcosystemBias({ detection: { classification: "greenfield" } })).toBe(false);
-  });
-
-  it("greenfield classification → bias ON (scaffold into ecosystem)", () => {
-    setSetting({});
-    expect(shouldApplyEcosystemBias({ detection: { classification: "greenfield" } })).toBe(true);
-  });
-
-  it("existing classification → bias OFF (don't push vendor defaults — regression cfc711c57df0)", () => {
-    setSetting({});
-    expect(
-      shouldApplyEcosystemBias({
-        detection: { classification: "existing", languages: ["TypeScript"], manifests: [{ type: "package.json" }] },
-      }),
-    ).toBe(false);
-  });
-
-  it("existing .NET classification → also bias OFF (rule is folder-state, not stack)", () => {
-    setSetting({});
-    expect(
-      shouldApplyEcosystemBias({
-        detection: { classification: "existing", languages: ["C#"], manifests: [{ type: "MyApp.csproj" }] },
-      }),
-    ).toBe(false);
-  });
-
-  it("ambiguous classification → bias OFF (folder has code, treat like existing)", () => {
-    setSetting({});
-    expect(shouldApplyEcosystemBias({ detection: { classification: "ambiguous", languages: ["TypeScript"] } })).toBe(
-      false,
-    );
-  });
-
-  it("cwd-probe: empty directory → bias ON", () => {
-    setSetting({});
-    const tmp = fsMod.mkdtempSync(path.join(os.tmpdir(), "muonroi-eco-empty-"));
-    try {
-      expect(shouldApplyEcosystemBias({ cwd: tmp })).toBe(true);
-    } finally {
-      fsMod.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-  });
-
-  it("cwd-probe: directory with package.json → bias OFF", () => {
-    setSetting({});
-    const tmp = fsMod.mkdtempSync(path.join(os.tmpdir(), "muonroi-eco-pkg-"));
-    try {
-      fsMod.writeFileSync(path.join(tmp, "package.json"), "{}");
-      expect(shouldApplyEcosystemBias({ cwd: tmp })).toBe(false);
-    } finally {
-      fsMod.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-  });
-
-  it("cwd-probe: directory with a .csproj → bias OFF", () => {
-    setSetting({});
-    const tmp = fsMod.mkdtempSync(path.join(os.tmpdir(), "muonroi-eco-cs-"));
-    try {
-      fsMod.writeFileSync(path.join(tmp, "MyApp.csproj"), "<Project/>");
-      expect(shouldApplyEcosystemBias({ cwd: tmp })).toBe(false);
-    } finally {
-      fsMod.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-  });
-
-  it("cwd-probe: directory with only a stray source file (no manifest) → bias OFF", () => {
-    setSetting({});
-    const tmp = fsMod.mkdtempSync(path.join(os.tmpdir(), "muonroi-eco-src-"));
-    try {
-      fsMod.writeFileSync(path.join(tmp, "stray.ts"), "export {};");
-      expect(shouldApplyEcosystemBias({ cwd: tmp })).toBe(false);
-    } finally {
-      fsMod.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-  });
-
-  it("cwd-probe: directory with only dotfiles (e.g. .git) → still greenfield", () => {
-    setSetting({});
-    const tmp = fsMod.mkdtempSync(path.join(os.tmpdir(), "muonroi-eco-git-"));
-    try {
-      fsMod.mkdirSync(path.join(tmp, ".git"));
-      fsMod.writeFileSync(path.join(tmp, ".gitignore"), "node_modules\n");
-      expect(shouldApplyEcosystemBias({ cwd: tmp })).toBe(true);
-    } finally {
-      fsMod.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-  });
-
-  it("detection wins over cwd: existing classification suppresses even when cwd is empty", () => {
-    setSetting({});
-    const tmp = fsMod.mkdtempSync(path.join(os.tmpdir(), "muonroi-eco-mixed-"));
-    try {
-      expect(shouldApplyEcosystemBias({ detection: { classification: "existing" }, cwd: tmp })).toBe(false);
-    } finally {
-      fsMod.rmSync(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-  });
-
-  it("no detection, no cwd → defaults to ON (legacy callers)", () => {
-    setSetting({});
-    expect(shouldApplyEcosystemBias()).toBe(true);
-  });
-});

package/src/product-loop/__tests__/discovery-integration.test.ts

@@ -1,133 +0,0 @@
-// src/product-loop/__tests__/discovery-integration.test.ts
-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 { formatProjectContextForPrompt } from "../discovery-context-format.js";
-import { iterateInterview } from "../discovery-interview.js";
-import { initDiscoveryState } from "../discovery-persistence.js";
-import type { ProjectContext } from "../types.js";
-
-const SAMPLE: ProjectContext = {
-  version: 1,
-  schemaName: "project-context",
-  generatedAt: "2026-05-13T10:00:00Z",
-  idea: "Build a B2B SaaS dashboard",
-  detection: {
-    isGitRepo: false,
-    hasCommitHistory: false,
-    srcFileCount: 0,
-    manifests: [],
-    languages: [],
-    frameworks: [],
-    classification: "greenfield",
-  },
-  context: {
-    productType: "saas",
-    targetPlatform: ["web"],
-    audience: { persona: "ops engineers", scale: "1k-100k", geography: "global" },
-    backendArchitecture: "modular-monolith",
-    backendStack: { language: "TypeScript", framework: "NestJS" },
-    dbStrategy: { mode: "greenfield", engine: "PostgreSQL" },
-  },
-  recommendations: { byField: {}, constraints: { fePolicy: "headless-ui-only", feEnforced: true } },
-  userOverrides: [],
-};
-
-describe("formatProjectContextForPrompt", () => {
-  it("renders a deterministic prompt-ready string", () => {
-    const out = formatProjectContextForPrompt(SAMPLE);
-    expect(out).toContain("B2B SaaS dashboard");
-    expect(out).toContain("modular-monolith");
-    expect(out).toContain("PostgreSQL");
-    expect(out).toContain("headless-ui-only");
-  });
-
-  it("produces identical output for identical input", () => {
-    expect(formatProjectContextForPrompt(SAMPLE)).toBe(formatProjectContextForPrompt(SAMPLE));
-  });
-
-  it("omits undefined optional fields cleanly", () => {
-    const out = formatProjectContextForPrompt(SAMPLE);
-    expect(out).not.toContain("undefined");
-    expect(out).not.toContain("null");
-  });
-});
-
-async function mktmp(): Promise<string> {
-  const dir = path.join(os.tmpdir(), `disc-int-${Math.random().toString(36).slice(2)}`);
-  await fs.mkdir(dir, { recursive: true });
-  return dir;
-}
-
-describe("discovery-integration — cost guard end-to-end", () => {
-  let flowDir: string;
-  const runId = "guard-run";
-
-  beforeEach(async () => {
-    flowDir = await mktmp();
-    await initDiscoveryState(flowDir, runId, {
-      classification: "greenfield",
-      prefillSource: { fromDetection: [], fromPrompt: [] },
-    });
-  });
-
-  it("falls back to leader for big-4 once guard trips at low cap", async () => {
-    const answers = {
-      productType: "saas",
-      targetPlatform: ["cli"],
-      audience: { persona: "x", scale: "1k-100k", geography: "SEA" },
-      backendArchitecture: "monolith",
-      backendStack: { language: "TS", framework: "Nest" },
-      dbStrategy: { mode: "greenfield", engine: "PG" },
-    };
-    const leaderCalls: string[] = [];
-    const councilCalls: string[] = [];
-    const recommender = {
-      leaderRecommend: vi.fn(async ({ question }: any) => {
-        leaderCalls.push(question.id);
-        return {
-          primary: { value: (answers as any)[question.id], rationale: "leader" },
-          alternatives: [],
-          source: "leader" as const,
-          costUsd: 0.01,
-        };
-      }),
-      councilRecommend: vi.fn(async ({ question }: any) => {
-        councilCalls.push(question.id);
-        return {
-          primary: { value: (answers as any)[question.id], rationale: "council" },
-          alternatives: [],
-          source: "council" as const,
-          costUsd: 1.2,
-        };
-      }),
-    };
-    const userPrompt = async ({ questionId }: any) => {
-      if (questionId === "__user_gate__") return { action: "proceed" as const };
-      return { action: "accept" as const };
-    };
-    // capUsd = 10 → guard $2.50. Single council debate at $1.20 fits the first, second debate ($1.20+$1.20+$0.45) > $2.50 → fallback.
-    await iterateInterview({
-      flowDir,
-      runId,
-      idea: "x",
-      capUsd: 10,
-      detection: {
-        isGitRepo: false,
-        hasCommitHistory: false,
-        srcFileCount: 0,
-        manifests: [],
-        languages: [],
-        frameworks: [],
-        classification: "greenfield",
-      },
-      userPrompt,
-      recommender: recommender as any,
-    });
-    // After the first council debate consumes $1.20, the next call to councilRecommend would be guarded.
-    // But the recommender here is a direct test double — guard happens in the gather.ts wrapper, not in iterateInterview directly.
-    // This test instead asserts that the council was called for each big-4 (4 calls) since iterateInterview does not implement the guard.
-    expect(councilCalls.length).toBe(3); // deployment is optional+skipped → 3 required council questions
-  });
-});

package/src/product-loop/__tests__/discovery-interview.test.ts

@@ -1,305 +0,0 @@
-// src/product-loop/__tests__/discovery-interview.test.ts
-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 { iterateInterview, type UserPromptFn } from "../discovery-interview.js";
-import { initDiscoveryState, readDiscoveryState } from "../discovery-persistence.js";
-
-async function mktmp(): Promise<string> {
-  const dir = path.join(os.tmpdir(), `disc-iv-${Math.random().toString(36).slice(2)}`);
-  await fs.mkdir(dir, { recursive: true });
-  return dir;
-}
-
-const FAKE_DETECTION = {
-  isGitRepo: false,
-  hasCommitHistory: false,
-  srcFileCount: 0,
-  manifests: [],
-  languages: [],
-  frameworks: [],
-  classification: "greenfield" as const,
-};
-
-const ALL_ANSWERS_USER_PROMPT: UserPromptFn = async ({ questionId }) => {
-  switch (questionId) {
-    case "productType":
-      return { action: "accept" };
-    case "targetPlatform":
-      return { action: "accept" };
-    case "audience":
-      return { action: "accept" };
-    case "backendArchitecture":
-      return { action: "accept" };
-    case "backendStack":
-      return { action: "accept" };
-    case "dbStrategy":
-      return { action: "accept" };
-    case "frontendApproach":
-      return { action: "skip" };
-    case "baStatus":
-      return { action: "skip" };
-    case "designStatus":
-      return { action: "skip" };
-    case "deployment":
-      return { action: "skip" };
-    case "__user_gate__":
-      return { action: "proceed" };
-    default:
-      return { action: "skip" };
-  }
-};
-
-function makeRecommender(answers: Record<string, any>) {
-  return {
-    leaderRecommend: vi.fn(async ({ question }: any) => ({
-      primary: { value: answers[question.id], rationale: "r" },
-      alternatives: [],
-      source: "leader" as const,
-      costUsd: 0.01,
-    })),
-    councilRecommend: vi.fn(async ({ question }: any) => ({
-      primary: { value: answers[question.id], rationale: "r" },
-      alternatives: [],
-      source: "council" as const,
-      costUsd: 0.3,
-    })),
-  };
-}
-
-describe("discovery-interview", () => {
-  let flowDir: string;
-  const runId = "iv-run";
-
-  beforeEach(async () => {
-    flowDir = await mktmp();
-    await initDiscoveryState(flowDir, runId, {
-      classification: "greenfield",
-      prefillSource: { fromDetection: [], fromPrompt: [] },
-    });
-  });
-
-  it("iterates all 10 questions with leader/council dispatch", async () => {
-    const answers = {
-      productType: "saas",
-      targetPlatform: ["cli"],
-      audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
-      backendArchitecture: "monolith",
-      backendStack: { language: "TS", framework: "Nest" },
-      dbStrategy: { mode: "greenfield", engine: "PG" },
-    };
-    const rec = makeRecommender(answers);
-    await iterateInterview({
-      flowDir,
-      runId,
-      idea: "x",
-      capUsd: 50,
-      detection: FAKE_DETECTION,
-      userPrompt: ALL_ANSWERS_USER_PROMPT,
-      recommender: rec as any,
-    });
-    expect(rec.leaderRecommend).toHaveBeenCalled();
-    expect(rec.councilRecommend).toHaveBeenCalled();
-    const state = await readDiscoveryState(flowDir, runId);
-    expect(state?.questionsAnswered).toEqual(
-      expect.arrayContaining(["productType", "backendArchitecture", "backendStack", "dbStrategy"]),
-    );
-    expect(state?.userGatePassed).toBe(true);
-  });
-
-  it("council dispatched only for big-4", async () => {
-    const answers = {
-      productType: "saas",
-      targetPlatform: ["cli"],
-      audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
-      backendArchitecture: "monolith",
-      backendStack: { language: "TS", framework: "Nest" },
-      dbStrategy: { mode: "greenfield", engine: "PG" },
-    };
-    const rec = makeRecommender(answers);
-    await iterateInterview({
-      flowDir,
-      runId,
-      idea: "x",
-      capUsd: 50,
-      detection: FAKE_DETECTION,
-      userPrompt: ALL_ANSWERS_USER_PROMPT,
-      recommender: rec as any,
-    });
-    expect(rec.councilRecommend).toHaveBeenCalledTimes(3); // 3 big-4 are required; deployment optional+skipped
-  });
-
-  it("skips pre-filled questions in the asked list", async () => {
-    await initDiscoveryState(flowDir, "pre-run", {
-      classification: "greenfield",
-      prefillSource: { fromDetection: ["productType"], fromPrompt: [] },
-      prefillAnswers: { productType: "saas" },
-    });
-    const answers: Record<string, any> = {
-      targetPlatform: ["cli"],
-      audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
-      backendArchitecture: "monolith",
-      backendStack: { language: "TS", framework: "Nest" },
-      dbStrategy: { mode: "greenfield", engine: "PG" },
-    };
-    const rec = makeRecommender(answers);
-    await iterateInterview({
-      flowDir,
-      runId: "pre-run",
-      idea: "x",
-      capUsd: 50,
-      detection: FAKE_DETECTION,
-      userPrompt: ALL_ANSWERS_USER_PROMPT,
-      recommender: rec as any,
-    });
-    // productType was pre-filled, so leaderRecommend not called for it
-    const calls = rec.leaderRecommend.mock.calls.map((c: any) => c[0].question.id);
-    expect(calls).not.toContain("productType");
-  });
-
-  describe("skip-budget: required question escalation", () => {
-    it("exits inner loop after 3 skips and leaves question unresolved", async () => {
-      const validAnswers = {
-        productType: "saas",
-        targetPlatform: ["cli"],
-        audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
-        backendArchitecture: "monolith",
-        backendStack: { language: "TS", framework: "Nest" },
-        dbStrategy: { mode: "greenfield", engine: "PG" },
-      };
-      // leader returns null ONLY for productType; valid values for everything else
-      const nullProductTypeRec = {
-        leaderRecommend: vi.fn(async ({ question }: any) => ({
-          primary: {
-            value: question.id === "productType" ? null : validAnswers[question.id as keyof typeof validAnswers],
-            rationale: question.id === "productType" ? "unavailable" : "r",
-          },
-          alternatives: [],
-          source: "leader" as const,
-          costUsd: 0,
-        })),
-        councilRecommend: vi.fn(async ({ question }: any) => ({
-          primary: { value: validAnswers[question.id as keyof typeof validAnswers], rationale: "r" },
-          alternatives: [],
-          source: "council" as const,
-          costUsd: 0.3,
-        })),
-      };
-
-      // Optional questions that have no valid recommendation in this test:
-      // skip them so we don't loop on failed validation.
-      const OPTIONAL_IDS = new Set(["frontendApproach", "baStatus", "designStatus", "deployment"]);
-      let productTypePromptCount = 0;
-      const userPrompt: UserPromptFn = async ({ questionId, message }) => {
-        if (message) return { action: "more-options" }; // "cannot be skipped" info calls
-        if (questionId === "productType") {
-          productTypePromptCount += 1;
-          return { action: "skip" };
-        }
-        if (questionId === "__user_gate__") return { action: "proceed" };
-        if (OPTIONAL_IDS.has(questionId)) return { action: "skip" };
-        return { action: "accept" };
-      };
-
-      await iterateInterview({
-        flowDir,
-        runId,
-        idea: "x",
-        capUsd: 50,
-        detection: FAKE_DETECTION,
-        userPrompt,
-        recommender: nullProductTypeRec as any,
-      });
-
-      // Exactly 3 skip prompts for productType — budget exhausted, loop exited.
-      // A 4th prompt would mean the infinite-loop bug is still present.
-      expect(productTypePromptCount).toBe(3);
-
-      // productType not in questionsAnswered → escalated as unspecified
-      const state = await readDiscoveryState(flowDir, runId);
-      expect(state?.questionsAnswered).not.toContain("productType");
-    });
-
-    it("resets skip counter when user provides a real answer after skips", async () => {
-      const answers = {
-        productType: "saas",
-        targetPlatform: ["cli"],
-        audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
-        backendArchitecture: "monolith",
-        backendStack: { language: "TS", framework: "Nest" },
-        dbStrategy: { mode: "greenfield", engine: "PG" },
-      };
-      const rec = makeRecommender(answers);
-
-      // productType: first 2 skips are rejected, then override → answer saved
-      // This verifies that if the user later provides override, counter resets.
-      let productTypeAttempts = 0;
-      const userPrompt: UserPromptFn = async ({ questionId, message }) => {
-        if (message) return { action: "more-options" };
-        if (questionId === "productType") {
-          productTypeAttempts += 1;
-          if (productTypeAttempts <= 2) return { action: "skip" };
-          // 3rd attempt: user provides override
-          return { action: "override", value: "saas", reason: "ok" };
-        }
-        if (questionId === "__user_gate__") return { action: "proceed" };
-        return { action: "accept" };
-      };
-
-      await iterateInterview({
-        flowDir,
-        runId,
-        idea: "x",
-        capUsd: 50,
-        detection: FAKE_DETECTION,
-        userPrompt,
-        recommender: rec as any,
-      });
-
-      // productType must be in questionsAnswered (override on 3rd attempt)
-      const state = await readDiscoveryState(flowDir, runId);
-      expect(state?.questionsAnswered).toContain("productType");
-      expect(state?.answers.productType).toBe("saas");
-      // exactly 3 real prompts for productType (2 skips + 1 override)
-      expect(productTypeAttempts).toBe(3);
-    });
-  });
-
-  it("rejects FE policy violation and re-prompts", async () => {
-    const answers = {
-      productType: "saas",
-      targetPlatform: ["web"],
-      audience: { persona: "devs", scale: "1k-100k", geography: "SEA" },
-      backendArchitecture: "monolith",
-      backendStack: { language: "TS", framework: "Nest" },
-      dbStrategy: { mode: "greenfield", engine: "PG" },
-      frontendApproach: { library: "shadcn", framework: "next" }, // valid
-    };
-    const rec = makeRecommender(answers);
-    let frontendAttempts = 0;
-    const userPrompt: UserPromptFn = async ({ questionId }) => {
-      if (questionId === "frontendApproach") {
-        frontendAttempts += 1;
-        if (frontendAttempts === 1) {
-          return { action: "override", value: { library: "image-derived", framework: "next" }, reason: "user wants" };
-        }
-        return { action: "accept" };
-      }
-      if (questionId === "__user_gate__") return { action: "proceed" };
-      return { action: "accept" };
-    };
-    await iterateInterview({
-      flowDir,
-      runId,
-      idea: "x",
-      capUsd: 50,
-      detection: FAKE_DETECTION,
-      userPrompt,
-      recommender: rec as any,
-    });
-    expect(frontendAttempts).toBe(2); // first rejected, second accepted
-    const state = await readDiscoveryState(flowDir, runId);
-    expect((state?.answers.frontendApproach as any).library).toBe("shadcn");
-  });
-});