muonroi-cli 1.3.4 → 1.4.1

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");
-  });
-});

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

@@ -1,75 +0,0 @@
-// src/product-loop/__tests__/discovery-migrations.test.ts
-import { describe, expect, it } from "vitest";
-import { CURRENT_SCHEMA_VERSION, migrators, readProjectContextWithMigration } from "../discovery-migrations.js";
-
-describe("discovery-migrations", () => {
-  it("CURRENT_SCHEMA_VERSION is 1", () => {
-    expect(CURRENT_SCHEMA_VERSION).toBe(1);
-  });
-
-  it("registry exposes v0 → v1 migrator", () => {
-    expect(typeof migrators[0]).toBe("function");
-  });
-
-  it("v0 → v1 migrator adds version and schemaName fields", () => {
-    const v0 = { idea: "x", context: {} };
-    const v1 = migrators[0](v0);
-    expect(v1.version).toBe(1);
-    expect(v1.schemaName).toBe("project-context");
-  });
-
-  it("v1 → v1 no-op preserves identity", () => {
-    if (migrators[1]) {
-      const v1 = { version: 1, schemaName: "project-context", idea: "x" };
-      expect(migrators[1](v1)).toEqual(v1);
-    } else {
-      expect(migrators[1]).toBeUndefined();
-    }
-  });
-
-  it("reads valid v1 directly", () => {
-    const raw = JSON.stringify({
-      version: 1,
-      schemaName: "project-context",
-      generatedAt: "2026-05-13T10:00:00Z",
-      idea: "test",
-      detection: {},
-      context: {},
-      recommendations: { byField: {}, constraints: { fePolicy: "headless-ui-only", feEnforced: true } },
-      userOverrides: [],
-    });
-    const ctx = readProjectContextWithMigration(raw);
-    expect(ctx).not.toBeNull();
-    expect(ctx?.version).toBe(1);
-  });
-
-  it("treats missing version as v0 and migrates", () => {
-    const raw = JSON.stringify({ idea: "legacy", context: {} });
-    const ctx = readProjectContextWithMigration(raw);
-    expect(ctx?.version).toBe(1);
-  });
-
-  it("returns null on unknown future version", () => {
-    const raw = JSON.stringify({ version: 99, idea: "future" });
-    expect(readProjectContextWithMigration(raw)).toBeNull();
-  });
-
-  it("returns null on malformed JSON", () => {
-    expect(readProjectContextWithMigration("not json")).toBeNull();
-    expect(readProjectContextWithMigration("")).toBeNull();
-  });
-
-  it("returns null if migrator throws", () => {
-    const raw = JSON.stringify({ version: 0 });
-    // tamper: replace v0 migrator to throw
-    const orig = migrators[0];
-    (migrators as any)[0] = () => {
-      throw new Error("boom");
-    };
-    try {
-      expect(readProjectContextWithMigration(raw)).toBeNull();
-    } finally {
-      (migrators as any)[0] = orig;
-    }
-  });
-});

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

@@ -1,171 +0,0 @@
-// src/product-loop/__tests__/discovery-persistence.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 } from "vitest";
-import {
-  acquireRunLock,
-  buildProjectContextFromState,
-  initDiscoveryState,
-  markUserGatePassed,
-  readDiscoveryState,
-  readProjectContext,
-  releaseRunLock,
-  resumeArtifactWriteIfNeeded,
-  saveDiscoveryAnswer,
-  writeProjectContext,
-} from "../discovery-persistence.js";
-
-async function mktmp(): Promise<string> {
-  const dir = path.join(os.tmpdir(), `disc-pers-${Math.random().toString(36).slice(2)}`);
-  await fs.mkdir(dir, { recursive: true });
-  return dir;
-}
-
-describe("discovery-persistence — state IO", () => {
-  let flowDir: string;
-  const runId = "run-test";
-
-  beforeEach(async () => {
-    flowDir = await mktmp();
-  });
-
-  it("returns null when state.md absent", async () => {
-    const state = await readDiscoveryState(flowDir, runId);
-    expect(state).toBeNull();
-  });
-
-  it("initDiscoveryState writes a fresh state with classification", async () => {
-    await initDiscoveryState(flowDir, runId, {
-      classification: "greenfield",
-      prefillSource: { fromDetection: [], fromPrompt: ["productType"] },
-    });
-    const state = await readDiscoveryState(flowDir, runId);
-    expect(state?.phase).toBe("interview");
-    expect(state?.classification).toBe("greenfield");
-    expect(state?.questionsAsked).toEqual([]);
-    expect(state?.userGatePassed).toBe(false);
-  });
-
-  it("saveDiscoveryAnswer appends to questionsAnswered idempotently", async () => {
-    await initDiscoveryState(flowDir, runId, {
-      classification: "greenfield",
-      prefillSource: { fromDetection: [], fromPrompt: [] },
-    });
-    await saveDiscoveryAnswer(flowDir, runId, "productType", "saas");
-    await saveDiscoveryAnswer(flowDir, runId, "productType", "saas"); // idempotent
-    const state = await readDiscoveryState(flowDir, runId);
-    expect(state?.questionsAnswered).toEqual(["productType"]);
-    expect(state?.answers.productType).toBe("saas");
-  });
-});
-
-describe("discovery-persistence — artifact + resume", () => {
-  let flowDir: string;
-  const runId = "run-art";
-
-  beforeEach(async () => {
-    flowDir = await mktmp();
-  });
-
-  it("writeProjectContext + readProjectContext round-trip", async () => {
-    const ctx = {
-      version: 1 as const,
-      schemaName: "project-context" as const,
-      generatedAt: "2026-05-13T10:00:00Z",
-      idea: "test",
-      detection: {
-        isGitRepo: false,
-        hasCommitHistory: false,
-        srcFileCount: 0,
-        manifests: [],
-        languages: [],
-        frameworks: [],
-        classification: "greenfield" as const,
-      },
-      context: {
-        productType: "saas" as const,
-        targetPlatform: ["web" as const],
-        audience: { persona: "devs", scale: "1k-100k" as const, geography: "SEA" },
-        backendArchitecture: "monolith" as const,
-        backendStack: { language: "TS", framework: "Nest" },
-        dbStrategy: { mode: "greenfield" as const, engine: "PG" },
-      },
-      recommendations: { byField: {}, constraints: { fePolicy: "headless-ui-only" as const, feEnforced: true } },
-      userOverrides: [],
-    };
-    await writeProjectContext(flowDir, runId, ctx);
-    const read = await readProjectContext(flowDir, runId);
-    expect(read?.idea).toBe("test");
-    expect(read?.version).toBe(1);
-  });
-
-  it("buildProjectContextFromState derives artifact from saved answers", async () => {
-    await initDiscoveryState(flowDir, runId, {
-      classification: "greenfield",
-      prefillSource: { fromDetection: [], fromPrompt: [] },
-    });
-    await saveDiscoveryAnswer(flowDir, runId, "productType", "saas");
-    const state = await readDiscoveryState(flowDir, runId);
-    const ctx = buildProjectContextFromState(state!, "idea text", {
-      isGitRepo: false,
-      hasCommitHistory: false,
-      srcFileCount: 0,
-      manifests: [],
-      languages: [],
-      frameworks: [],
-      classification: "greenfield",
-    });
-    expect(ctx.context.productType).toBe("saas");
-    expect(ctx.idea).toBe("idea text");
-  });
-
-  it("resume from awaiting-artifact-write re-derives and writes idempotently", async () => {
-    await initDiscoveryState(flowDir, runId, {
-      classification: "greenfield",
-      prefillSource: { fromDetection: [], fromPrompt: [] },
-    });
-    await saveDiscoveryAnswer(flowDir, runId, "productType", "saas");
-    await saveDiscoveryAnswer(flowDir, runId, "targetPlatform", ["web"]);
-    await saveDiscoveryAnswer(flowDir, runId, "audience", { persona: "x", scale: "1k-100k", geography: "SEA" });
-    await saveDiscoveryAnswer(flowDir, runId, "backendArchitecture", "monolith");
-    await saveDiscoveryAnswer(flowDir, runId, "backendStack", { language: "TS", framework: "Nest" });
-    await saveDiscoveryAnswer(flowDir, runId, "dbStrategy", { mode: "greenfield", engine: "PG" });
-    await markUserGatePassed(flowDir, runId);
-
-    // simulate crash: artifact not written yet
-    expect(await readProjectContext(flowDir, runId)).toBeNull();
-
-    await resumeArtifactWriteIfNeeded(flowDir, runId, "idea text", {
-      isGitRepo: false,
-      hasCommitHistory: false,
-      srcFileCount: 0,
-      manifests: [],
-      languages: [],
-      frameworks: [],
-      classification: "greenfield",
-    });
-    const state = await readDiscoveryState(flowDir, runId);
-    expect(state?.phase).toBe("done");
-    expect(await readProjectContext(flowDir, runId)).not.toBeNull();
-
-    // calling again is a no-op
-    await resumeArtifactWriteIfNeeded(flowDir, runId, "idea text", {
-      isGitRepo: false,
-      hasCommitHistory: false,
-      srcFileCount: 0,
-      manifests: [],
-      languages: [],
-      frameworks: [],
-      classification: "greenfield",
-    });
-  });
-
-  it("lockfile prevents concurrent runs", async () => {
-    await acquireRunLock(flowDir, runId);
-    await expect(acquireRunLock(flowDir, runId)).rejects.toThrow(/already running|locked/i);
-    await releaseRunLock(flowDir, runId);
-    await expect(acquireRunLock(flowDir, runId)).resolves.toBeUndefined();
-    await releaseRunLock(flowDir, runId);
-  });
-});