muonroi-cli 1.2.3 → 1.3.2

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

@@ -0,0 +1,76 @@
+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 });
+  });
+
+  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

@@ -0,0 +1,195 @@
+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();
+  });
+});

package/src/product-loop/__tests__/design-output.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { emitDesignSpec } from "../design-output.js";
+
+describe("design-output", () => {
+  it("emits a valid DesignSpec for a single scene", () => {
+    const spec = emitDesignSpec({
+      scenes: [
+        {
+          id: "composer",
+          name: "Composer",
+          layout: {
+            id: "root",
+            role: "dialog",
+            children: [{ id: "input", role: "textbox" }],
+          },
+          states: [{ name: "loading", patches: [{ id: "input", state: "loading" }] }],
+        },
+      ],
+    });
+    expect(spec.mode).toBe("design");
+    expect(spec.version).toBe("0.4.0");
+    expect(spec.scenes[0].id).toBe("composer");
+  });
+
+  it("rejects orphan patches (id not in layout)", () => {
+    expect(() =>
+      emitDesignSpec({
+        scenes: [
+          {
+            id: "a",
+            name: "A",
+            layout: { id: "root", role: "dialog" },
+            states: [{ name: "x", patches: [{ id: "missing", state: "loading" }] }],
+          },
+        ],
+      }),
+    ).toThrow(/patch references unknown id/);
+  });
+});

package/src/product-loop/__tests__/discover.test.ts

@@ -0,0 +1,98 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { discoverProject, formatDiscoverySummary } from "../discover.js";
+
+async function tmpDir(): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), "discover-"));
+}
+
+describe("discoverProject", () => {
+  it("returns hasProject=false when cwd is undefined", async () => {
+    const r = await discoverProject(undefined);
+    expect(r.hasProject).toBe(false);
+    expect(r.prefilled.size).toBe(0);
+  });
+
+  it("returns hasProject=false for empty dir", async () => {
+    const dir = await tmpDir();
+    const r = await discoverProject(dir);
+    expect(r.hasProject).toBe(false);
+    expect(r.prefilled.size).toBe(0);
+  });
+
+  it("detects package.json with test script + framework", async () => {
+    const dir = await tmpDir();
+    await fs.writeFile(
+      path.join(dir, "package.json"),
+      JSON.stringify({
+        name: "demo",
+        scripts: { test: "vitest run" },
+        dependencies: { react: "18.0.0" },
+        devDependencies: { vitest: "1.0.0" },
+      }),
+    );
+    const r = await discoverProject(dir);
+    expect(r.hasProject).toBe(true);
+    expect(r.prefilled.get("tech-constraints")).toMatch(/TypeScript\/JavaScript/);
+    expect(r.prefilled.get("tech-constraints")).toMatch(/React/);
+    expect(r.prefilled.get("tech-constraints")).toMatch(/Vitest/);
+    expect(r.prefilled.get("success-metric")).toMatch(/vitest run/);
+  });
+
+  it("ignores placeholder 'no test specified' script", async () => {
+    const dir = await tmpDir();
+    await fs.writeFile(
+      path.join(dir, "package.json"),
+      JSON.stringify({
+        name: "demo",
+        scripts: { test: 'echo "Error: no test specified" && exit 1' },
+      }),
+    );
+    const r = await discoverProject(dir);
+    expect(r.prefilled.has("tech-constraints")).toBe(true);
+    expect(r.prefilled.has("success-metric")).toBe(false);
+  });
+
+  it("detects Cargo.toml and infers cargo test", async () => {
+    const dir = await tmpDir();
+    await fs.writeFile(path.join(dir, "Cargo.toml"), `[package]\nname = "demo"\n`);
+    const r = await discoverProject(dir);
+    expect(r.prefilled.get("tech-constraints")).toBe("Rust");
+    expect(r.prefilled.get("success-metric")).toMatch(/cargo test/);
+  });
+
+  it("detects go.mod and infers go test", async () => {
+    const dir = await tmpDir();
+    await fs.writeFile(path.join(dir, "go.mod"), "module demo\n");
+    const r = await discoverProject(dir);
+    expect(r.prefilled.get("tech-constraints")).toBe("Go");
+    expect(r.prefilled.get("success-metric")).toMatch(/go test/);
+  });
+
+  it("survives an unparseable package.json", async () => {
+    const dir = await tmpDir();
+    await fs.writeFile(path.join(dir, "package.json"), "{ not json");
+    const r = await discoverProject(dir);
+    expect(r.hasProject).toBe(true);
+    expect(r.prefilled.has("tech-constraints")).toBe(true);
+    expect(r.prefilled.has("success-metric")).toBe(false);
+  });
+
+  it("formatDiscoverySummary returns greenfield message when no project", () => {
+    const s = formatDiscoverySummary({ hasProject: false, prefilled: new Map(), evidence: [], notes: [] });
+    expect(s).toMatch(/greenfield/i);
+  });
+
+  it("formatDiscoverySummary lists evidence when prefilled", () => {
+    const s = formatDiscoverySummary({
+      hasProject: true,
+      prefilled: new Map([["tech-constraints", "Rust"]]),
+      evidence: [{ dim: "tech-constraints", source: "Cargo.toml", value: "Rust" }],
+      notes: [],
+    });
+    expect(s).toMatch(/Cargo.toml/);
+    expect(s).toMatch(/Skipping 1/);
+  });
+});

package/src/product-loop/__tests__/discovery-council-runner.test.ts

@@ -0,0 +1,13 @@
+// src/product-loop/__tests__/discovery-council-runner.test.ts
+import { describe, expect, it } from "vitest";
+import { buildBig4DebatePlan } from "../discovery-council-runner.js";
+
+describe("discovery-council-runner — DebatePlan", () => {
+  it("plan has intentSummary, 3 stances (named pragmatist/scaler/cost-optimizer), plannedRounds=1, outputShape", () => {
+    const plan = buildBig4DebatePlan({ questionId: "backendArchitecture", contextSummary: "saas, 1k-100k, SEA" });
+    expect(plan.plannedRounds).toBe(1);
+    expect(plan.stances.map((s: any) => s.name)).toEqual(["pragmatist", "scaler", "cost-optimizer"]);
+    expect(plan.intentSummary).toContain("backendArchitecture");
+    expect(plan.outputShape).toBeDefined();
+  });
+});

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

@@ -0,0 +1,180 @@
+// src/product-loop/__tests__/discovery-detection.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 { detectExistingProject } from "../discovery-detection.js";
+
+async function mktmp(): Promise<string> {
+  const dir = path.join(os.tmpdir(), `detect-${Math.random().toString(36).slice(2)}`);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+describe("discovery-detection", () => {
+  let cwd: string;
+  beforeEach(async () => {
+    cwd = await mktmp();
+  });
+
+  it("classifies empty cwd as greenfield", async () => {
+    const sig = await detectExistingProject(cwd);
+    expect(sig.classification).toBe("greenfield");
+    expect(sig.srcFileCount).toBe(0);
+    expect(sig.manifests).toEqual([]);
+  });
+
+  it("classifies cwd with only README as greenfield", async () => {
+    await fs.writeFile(path.join(cwd, "README.md"), "# x");
+    const sig = await detectExistingProject(cwd);
+    expect(sig.classification).toBe("greenfield");
+  });
+
+  it("classifies cwd with package.json + 10 src files as existing", async () => {
+    await fs.writeFile(path.join(cwd, "package.json"), JSON.stringify({ dependencies: { react: "^18" } }));
+    await fs.mkdir(path.join(cwd, "src"));
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "src", `f${i}.ts`), "export const x = 1;");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.classification).toBe("existing");
+    expect(sig.srcFileCount).toBeGreaterThan(5);
+    expect(sig.manifests[0].type).toBe("package.json");
+    expect(sig.languages).toContain("TypeScript");
+    expect(sig.frameworks).toContain("react");
+  });
+
+  it("detects Cargo.toml as Rust manifest", async () => {
+    await fs.writeFile(path.join(cwd, "Cargo.toml"), '[package]\nname = "x"');
+    await fs.mkdir(path.join(cwd, "src"));
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "src", `f${i}.rs`), "fn main() {}");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.manifests[0].type).toBe("Cargo.toml");
+    expect(sig.languages).toContain("Rust");
+  });
+
+  it("detects go.mod as Go manifest", async () => {
+    await fs.writeFile(path.join(cwd, "go.mod"), "module x\n");
+    await fs.mkdir(path.join(cwd, "internal"));
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "internal", `f${i}.go`), "package x");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.manifests[0].type).toBe("go.mod");
+    expect(sig.languages).toContain("Go");
+  });
+
+  it("classifies empty package.json (no deps) as ambiguous", async () => {
+    await fs.writeFile(path.join(cwd, "package.json"), JSON.stringify({}));
+    await fs.mkdir(path.join(cwd, "src"));
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "src", `f${i}.ts`), "export const x = 1;");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.classification).toBe("ambiguous");
+  });
+
+  it("classifies scaffolded but untouched project as ambiguous", async () => {
+    await fs.writeFile(path.join(cwd, "package.json"), JSON.stringify({ dependencies: { next: "^14" } }));
+    // only 2 src files = scaffold
+    await fs.mkdir(path.join(cwd, "src"));
+    await fs.writeFile(path.join(cwd, "src", "index.ts"), "export {}");
+    await fs.writeFile(path.join(cwd, "src", "app.tsx"), "export {}");
+    const sig = await detectExistingProject(cwd);
+    expect(sig.classification).toBe("ambiguous");
+  });
+
+  it("classifies multiple manifests (polyglot) as ambiguous", async () => {
+    await fs.writeFile(
+      path.join(cwd, "package.json"),
+      JSON.stringify({ dependencies: { react: "^18", a: "1", b: "1", c: "1", d: "1", e: "1" } }),
+    );
+    await fs.writeFile(
+      path.join(cwd, "pyproject.toml"),
+      "[tool.poetry]\nname='x'\ndependencies = ['a','b','c','d','e']",
+    );
+    await fs.mkdir(path.join(cwd, "src"));
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "src", `f${i}.ts`), "export {}");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.manifests.length).toBeGreaterThanOrEqual(2);
+    expect(sig.classification).toBe("ambiguous");
+  });
+
+  it("treats no-git+src as still classifiable on manifest", async () => {
+    await fs.writeFile(
+      path.join(cwd, "package.json"),
+      JSON.stringify({ dependencies: { a: "1", b: "1", c: "1", d: "1", e: "1", f: "1" } }),
+    );
+    await fs.mkdir(path.join(cwd, "src"));
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "src", `f${i}.ts`), "export {}");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.isGitRepo).toBe(false);
+    expect(sig.classification).toBe("existing");
+  });
+
+  it("counts srcFiles ignoring node_modules and dist", async () => {
+    await fs.writeFile(
+      path.join(cwd, "package.json"),
+      JSON.stringify({ dependencies: { a: "1", b: "1", c: "1", d: "1", e: "1", f: "1" } }),
+    );
+    await fs.mkdir(path.join(cwd, "node_modules", "lib"), { recursive: true });
+    await fs.writeFile(path.join(cwd, "node_modules", "lib", "f.ts"), "export {}");
+    await fs.mkdir(path.join(cwd, "dist"), { recursive: true });
+    await fs.writeFile(path.join(cwd, "dist", "out.js"), "export {}");
+    await fs.mkdir(path.join(cwd, "src"));
+    for (let i = 0; i < 6; i++) {
+      await fs.writeFile(path.join(cwd, "src", `f${i}.ts`), "export {}");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.srcFileCount).toBe(6);
+  });
+
+  it("vendored node_modules without root manifest is ambiguous", async () => {
+    await fs.mkdir(path.join(cwd, "node_modules", "lib"), { recursive: true });
+    await fs.mkdir(path.join(cwd, "vendor"), { recursive: true });
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "vendor", `f${i}.ts`), "export {}");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.manifests.length).toBe(0);
+    expect(sig.srcFileCount).toBe(10);
+    expect(sig.classification).toBe("ambiguous");
+  });
+
+  it("returns greenfield with warning when fs access denied (smoke)", async () => {
+    // Simulating EACCES is platform-dependent; verify the helper does not throw on a non-existent path
+    const sig = await detectExistingProject(path.join(cwd, "does-not-exist"));
+    expect(sig.classification).toBe("greenfield");
+  });
+
+  it("zero-weight unreadable manifest is still listed", async () => {
+    // create a directory with the manifest name to make read fail
+    await fs.mkdir(path.join(cwd, "package.json"));
+    const sig = await detectExistingProject(cwd);
+    if (sig.manifests.length > 0) {
+      expect(sig.manifests[0].weight).toBe(0);
+    } else {
+      // some platforms treat dir-as-file differently; passing is also OK
+      expect(sig.manifests).toEqual([]);
+    }
+  });
+
+  it("counts only ext-mapped src files (no random text)", async () => {
+    await fs.writeFile(
+      path.join(cwd, "package.json"),
+      JSON.stringify({ dependencies: { a: "1", b: "1", c: "1", d: "1", e: "1", f: "1" } }),
+    );
+    await fs.mkdir(path.join(cwd, "src"));
+    for (let i = 0; i < 10; i++) {
+      await fs.writeFile(path.join(cwd, "src", `f${i}.txt`), "not source");
+    }
+    const sig = await detectExistingProject(cwd);
+    expect(sig.srcFileCount).toBe(0);
+  });
+});