muonroi-cli 1.8.1 → 1.8.4

package/dist/src/product-loop/__tests__/discover.test.js

@@ -1,83 +0,0 @@
-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() {
-    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/);
-    });
-});
-//# sourceMappingURL=discover.test.js.map

package/dist/src/product-loop/__tests__/discovery-context-format.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Regression tests for formatProjectContextForPrompt — session
- * e2660a052918 crashed at "ctx.context.backendStack.language" because
- * `backendStack` was marked as prefilled-from-detection (interview
- * skipped the question) but the prefillAnswers map didn't actually
- * contain a backendStack value. Downstream the formatter accessed
- * `.language` of undefined and the /ideal loop silently halted.
- *
- * The formatter must NEVER throw on a partial context. Every consumer
- * is a leader prompt; we'd rather emit "(unspecified)" than crash the
- * loop.
- */
-export {};

package/dist/src/product-loop/__tests__/discovery-context-format.test.js

@@ -1,100 +0,0 @@
-/**
- * Regression tests for formatProjectContextForPrompt — session
- * e2660a052918 crashed at "ctx.context.backendStack.language" because
- * `backendStack` was marked as prefilled-from-detection (interview
- * skipped the question) but the prefillAnswers map didn't actually
- * contain a backendStack value. Downstream the formatter accessed
- * `.language` of undefined and the /ideal loop silently halted.
- *
- * The formatter must NEVER throw on a partial context. Every consumer
- * is a leader prompt; we'd rather emit "(unspecified)" than crash the
- * loop.
- */
-import { describe, expect, it } from "vitest";
-import { formatProjectContextForPrompt } from "../discovery-context-format.js";
-function makeDetection() {
-    return {
-        isGitRepo: false,
-        hasCommitHistory: false,
-        srcFileCount: 0,
-        manifests: [],
-        languages: [],
-        frameworks: [],
-        classification: "greenfield",
-    };
-}
-function makeCtx(over = {}) {
-    return {
-        version: 1,
-        schemaName: "project-context",
-        generatedAt: new Date().toISOString(),
-        idea: "test idea",
-        detection: makeDetection(),
-        context: over,
-        recommendations: {
-            byField: {},
-            constraints: { fePolicy: "headless-ui-only", feEnforced: true },
-        },
-        userOverrides: [],
-    };
-}
-describe("formatProjectContextForPrompt — partial context resilience", () => {
-    it("does not throw when context is COMPLETELY empty (regression e2660a052918)", () => {
-        const ctx = makeCtx({});
-        expect(() => formatProjectContextForPrompt(ctx)).not.toThrow();
-        const out = formatProjectContextForPrompt(ctx);
-        expect(out).toContain("Idea: test idea");
-    });
-    it("does not throw when backendStack is missing (the actual crash field)", () => {
-        const ctx = makeCtx({
-            productType: "internal-tool",
-            targetPlatform: ["cli"],
-        });
-        expect(() => formatProjectContextForPrompt(ctx)).not.toThrow();
-        const out = formatProjectContextForPrompt(ctx);
-        expect(out).toContain("Product type: internal-tool");
-        expect(out).not.toContain("Backend stack:");
-    });
-    it("does not throw when audience is partial (e.g. only persona)", () => {
-        const ctx = makeCtx({
-            audience: { persona: "developer" },
-        });
-        expect(() => formatProjectContextForPrompt(ctx)).not.toThrow();
-        const out = formatProjectContextForPrompt(ctx);
-        expect(out).toContain("developer");
-    });
-    it("renders backendStack when present with all fields", () => {
-        const ctx = makeCtx({
-            backendStack: { language: "TypeScript", framework: "Hono", runtime: "Bun" },
-        });
-        const out = formatProjectContextForPrompt(ctx);
-        expect(out).toContain("Backend stack: TypeScript / Hono on Bun");
-    });
-    it("renders backendStack without runtime gracefully", () => {
-        const ctx = makeCtx({
-            backendStack: { language: "TypeScript", framework: "Hono" },
-        });
-        const out = formatProjectContextForPrompt(ctx);
-        expect(out).toContain("Backend stack: TypeScript / Hono");
-        expect(out).not.toContain(" on ");
-    });
-    it("handles backendStack with only framework or only language", () => {
-        const ctx1 = makeCtx({
-            backendStack: { framework: "Express" },
-        });
-        expect(() => formatProjectContextForPrompt(ctx1)).not.toThrow();
-        expect(formatProjectContextForPrompt(ctx1)).toContain("Express");
-        const ctx2 = makeCtx({
-            backendStack: { language: "Rust" },
-        });
-        expect(() => formatProjectContextForPrompt(ctx2)).not.toThrow();
-        expect(formatProjectContextForPrompt(ctx2)).toContain("Rust");
-    });
-    it("does not throw when recommendations.constraints is missing", () => {
-        const ctx = makeCtx({});
-        // biome-ignore lint/suspicious/noExplicitAny: deliberately remove constraints
-        ctx.recommendations = undefined;
-        expect(() => formatProjectContextForPrompt(ctx)).not.toThrow();
-    });
-});
-//# sourceMappingURL=discovery-context-format.test.js.map

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,13 +0,0 @@
-// 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) => s.name)).toEqual(["pragmatist", "scaler", "cost-optimizer"]);
-        expect(plan.intentSummary).toContain("backendArchitecture");
-        expect(plan.outputShape).toBeDefined();
-    });
-});
-//# sourceMappingURL=discovery-council-runner.test.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/product-loop/__tests__/discovery-detection.test.js

@@ -1,151 +0,0 @@
-// 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() {
-    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;
-    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);
-    });
-});
-//# sourceMappingURL=discovery-detection.test.js.map

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

@@ -1,8 +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.
- */
-export {};

package/dist/src/product-loop/__tests__/discovery-ecosystem.test.js

@@ -1,209 +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 = 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.mockReturnValueOnce({});
-        expect(isEcosystemBiasEnabled()).toBe(true);
-    });
-    it("returns true when discoveryEcosystemBias === true", () => {
-        loadUserSettings.mockReturnValueOnce({
-            discoveryEcosystemBias: true,
-        });
-        expect(isEcosystemBiasEnabled()).toBe(true);
-    });
-    it("returns false only when discoveryEcosystemBias === false", () => {
-        loadUserSettings.mockReturnValueOnce({
-            discoveryEcosystemBias: false,
-        });
-        expect(isEcosystemBiasEnabled()).toBe(false);
-    });
-    it("fails OPEN when settings read throws", () => {
-        loadUserSettings.mockImplementationOnce(() => {
-            throw new Error("disk error");
-        });
-        expect(isEcosystemBiasEnabled()).toBe(true);
-    });
-});
-describe("shouldApplyEcosystemBias", () => {
-    const setSetting = (value) => loadUserSettings.mockReturnValueOnce(value);
-    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);
-    });
-});
-//# sourceMappingURL=discovery-ecosystem.test.js.map

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

@@ -1 +0,0 @@
-export {};