muonroi-cli 1.8.1 → 1.8.4

package/dist/src/orchestrator/tool-loop-cap.test.js

@@ -1,176 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createToolLoopCapPredicate, DEFAULT_TOOL_LOOP_BUMP } from "./tool-loop-cap.js";
-function steps(n) {
-    return { steps: Array.from({ length: n }, () => ({})) };
-}
-/**
- * Build a steps array where each step has a single bash tool call. Used by
- * the pattern-detector tests below. Pass an array of commands — one per step.
- */
-function bashSteps(commands) {
-    return {
-        steps: commands.map((command) => ({
-            toolCalls: [{ toolName: "bash", input: { command } }],
-        })),
-    };
-}
-describe("createToolLoopCapPredicate — cap guard", () => {
-    it("returns false while step count is below cap", async () => {
-        const stop = createToolLoopCapPredicate({ initialCap: 100 });
-        expect(await stop(steps(0))).toBe(false);
-        expect(await stop(steps(50))).toBe(false);
-        expect(await stop(steps(99))).toBe(false);
-    });
-    it("hard-stops at the cap when no ask handler is wired (legacy headless)", async () => {
-        const stop = createToolLoopCapPredicate({ initialCap: 10 });
-        expect(await stop(steps(10))).toBe(true);
-    });
-    it("continue verdict raises the cap by the default bump (50) and resumes", async () => {
-        const ask = vi.fn().mockResolvedValueOnce("continue").mockResolvedValueOnce("stop");
-        const stop = createToolLoopCapPredicate({ initialCap: 100, ask });
-        expect(await stop(steps(100))).toBe(false);
-        expect(ask).toHaveBeenCalledWith({ kind: "cap", stepNumber: 100, cap: 100, bumpBy: DEFAULT_TOOL_LOOP_BUMP });
-        expect(await stop(steps(149))).toBe(false);
-        expect(ask).toHaveBeenCalledTimes(1);
-        expect(await stop(steps(150))).toBe(true);
-        expect(ask).toHaveBeenLastCalledWith({ kind: "cap", stepNumber: 150, cap: 150, bumpBy: DEFAULT_TOOL_LOOP_BUMP });
-    });
-    it("respects custom bumpBy", async () => {
-        const ask = vi.fn().mockResolvedValueOnce("continue").mockResolvedValueOnce("stop");
-        const stop = createToolLoopCapPredicate({ initialCap: 10, bumpBy: 5, ask });
-        expect(await stop(steps(10))).toBe(false);
-        expect(await stop(steps(14))).toBe(false);
-        expect(await stop(steps(15))).toBe(true);
-        expect(ask).toHaveBeenLastCalledWith({ kind: "cap", stepNumber: 15, cap: 15, bumpBy: 5 });
-    });
-    it("stop verdict halts without bumping the cap", async () => {
-        const ask = vi.fn().mockResolvedValue("stop");
-        const stop = createToolLoopCapPredicate({ initialCap: 5, ask });
-        expect(await stop(steps(5))).toBe(true);
-        expect(ask).toHaveBeenCalledOnce();
-    });
-});
-describe("createToolLoopCapPredicate — pattern guard", () => {
-    // Each call to stop(...) must show monotonically-growing step counts because
-    // the predicate only processes the newly-added tail. We simulate streamText's
-    // behaviour by calling stop after each new step.
-    async function feed(stop, commands) {
-        const verdicts = [];
-        for (let i = 1; i <= commands.length; i++) {
-            verdicts.push(await stop(bashSteps(commands.slice(0, i))));
-        }
-        return verdicts;
-    }
-    it("does not fire when patterns vary", async () => {
-        const ask = vi.fn();
-        const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-        await feed(stop, ["git status", "ls -la", "git log -5", "bun run build", "cat README.md"]);
-        expect(ask).not.toHaveBeenCalled();
-    });
-    // Phase 5 BUG-F+G: verification commands (vitest/tsc/test/lint) are now
-    // exempt from pattern detection — agents re-run them as part of normal
-    // edit→typecheck→fix cycles, and counting them as loop tripped the askcard
-    // on legitimate work. We swap to git diff invocations for the same scenario.
-    it("fires when 3-of-5 bash calls collapse to the same canonical hash", async () => {
-        const ask = vi.fn().mockResolvedValue("stop");
-        const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-        const verdicts = await feed(stop, [
-            "ls -la",
-            "cat package.json",
-            "git diff HEAD",
-            "git diff HEAD > /tmp/diff.txt",
-            "git diff HEAD 2>&1",
-        ]);
-        expect(ask).toHaveBeenCalledOnce();
-        expect(ask).toHaveBeenCalledWith({
-            kind: "pattern",
-            toolName: "bash",
-            count: 3,
-            windowSize: 5,
-            stepNumber: 5,
-            naturalCeiling: undefined,
-        });
-        expect(verdicts[verdicts.length - 1]).toBe(true);
-    });
-    it("continue verdict clears the ring and resumes", async () => {
-        const ask = vi.fn().mockResolvedValueOnce("continue");
-        const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-        // Fire pattern detection on call 3.
-        const v1 = await feed(stop, ["git diff HEAD | head", "git diff HEAD | tail", "git diff HEAD > /tmp/x"]);
-        expect(ask).toHaveBeenCalledOnce();
-        // Continue → ring cleared → 3 more identical calls should NOT fire again
-        // (one-shot per session).
-        await feed(stop, ["git diff HEAD | wc -l", "git diff HEAD | grep diff", "git diff HEAD > /tmp/y"]);
-        expect(ask).toHaveBeenCalledOnce();
-        expect(v1.every((v) => v === false)).toBe(true);
-    });
-    it("respects custom patternWindow / patternThreshold", async () => {
-        const ask = vi.fn().mockResolvedValue("stop");
-        const stop = createToolLoopCapPredicate({
-            initialCap: 1000,
-            ask,
-            patternWindow: 3,
-            patternThreshold: 2,
-        });
-        await feed(stop, ["git status", "git diff HEAD", "git diff HEAD > /tmp/x"]);
-        expect(ask).toHaveBeenCalledOnce();
-        expect(ask).toHaveBeenCalledWith({
-            kind: "pattern",
-            toolName: "bash",
-            count: 2,
-            windowSize: 3,
-            stepNumber: 3,
-            naturalCeiling: undefined,
-        });
-    });
-    it("does not fire without an ask handler (headless safety)", async () => {
-        const stop = createToolLoopCapPredicate({ initialCap: 1000 });
-        const verdicts = await feed(stop, ["git diff HEAD | head", "git diff HEAD | tail", "git diff HEAD > /tmp/x"]);
-        expect(verdicts.every((v) => v === false)).toBe(true);
-    });
-    // Phase 5 BUG-F — verification commands MUST NOT trigger the pattern guard
-    // even when run 5x in a row (edit→typecheck→fix iteration is normal work).
-    it("does NOT fire when verification commands are repeated", async () => {
-        const ask = vi.fn().mockResolvedValue("stop");
-        const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-        await feed(stop, ["bunx tsc --noEmit", "bunx tsc --noEmit", "bunx tsc --noEmit", "bunx tsc --noEmit"]);
-        expect(ask).not.toHaveBeenCalled();
-    });
-    // Phase 5 BUG-G — pipe-native tools (grep, sed, awk, jq, find) preserve
-    // their pipe chain in the canonical form because the pipe IS the query.
-    // Three legitimately-different grep filter chains on the same file should
-    // NOT collide.
-    it("does NOT fire when grep pipe-chains differ on the same target", async () => {
-        const ask = vi.fn().mockResolvedValue("stop");
-        const stop = createToolLoopCapPredicate({ initialCap: 1000, ask });
-        await feed(stop, [
-            'grep -n "^import " src/index.ts | head -60',
-            'grep -n "^import " src/index.ts | wc -l',
-            'grep -n "^import " src/index.ts | grep -v type',
-        ]);
-        expect(ask).not.toHaveBeenCalled();
-    });
-    // Phase 5 BUG-H — pattern info carries stepNumber + naturalCeiling so the
-    // UI can pick a context-aware default action.
-    it("propagates stepNumber and naturalCeiling to the ask handler", async () => {
-        const ask = vi.fn().mockResolvedValue("stop");
-        const stop = createToolLoopCapPredicate({
-            initialCap: 1000,
-            ask,
-            naturalCeiling: 18,
-        });
-        await feed(stop, [
-            "git diff HEAD",
-            "git diff HEAD | head",
-            "ls",
-            "git diff HEAD | wc -l", // <- pattern fires here (3 git-diffs in window)
-            "git diff HEAD > /tmp/x",
-        ]);
-        expect(ask).toHaveBeenCalledWith(expect.objectContaining({
-            kind: "pattern",
-            stepNumber: 4,
-            naturalCeiling: 18,
-        }));
-    });
-});
-//# sourceMappingURL=tool-loop-cap.test.js.map

package/dist/src/orchestrator/tool-repetition-detector.test.d.ts

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

package/dist/src/orchestrator/tool-repetition-detector.test.js

@@ -1,101 +0,0 @@
-/**
- * Regression for session 080fe2fcbf24 (2026-05-26): Qwen3-30B emitted the
- * same malformed grep args 4× consecutively, ate the TPM budget, then 429.
- *
- * Tests pin:
- *   - 1st + 2nd identical failures do NOT trigger (TRIGGER_RUN_LENGTH=3)
- *   - 3rd identical failure DOES trigger (shouldAbort=true)
- *   - 4th+ identical failures don't re-trigger (abortFired latch — caller
- *     decides whether to end; we shouldn't tell them to abort twice)
- *   - Different input resets the counter even with same tool
- *   - Different tool resets the counter
- *   - Different error message resets the counter (model might be recovering)
- *   - Null/empty sessionId is a no-op (so utility callers don't crash)
- *   - recordToolSuccess clears the run (mixed success/fail sequences reset)
- */
-import { afterEach, describe, expect, it } from "vitest";
-import { _resetForTests, buildToolRepetitionAbortMessage, recordToolError, recordToolSuccess, } from "./tool-repetition-detector.js";
-const SID = "sess-test";
-const MALFORMED_GREP_ARGS = {
-    pattern: "catch\\s*\\{\\s*\\},",
-    path: ".",
-    include: "*.ts",
-};
-const PARSE_ERROR = 'Invalid input for tool grep: JSON parsing failed: Text:  {"pattern": "catch\\\\s*\\\\{\\\\s*\\\\}, "path": ".", "include": "*.ts"}.\nError message: JSON Parse error: Expected \'}\'';
-describe("tool-repetition-detector", () => {
-    afterEach(() => _resetForTests());
-    it("does not trigger on the first two identical failures", () => {
-        const r1 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r1).toEqual({ runLength: 1, shouldAbort: false });
-        const r2 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r2).toEqual({ runLength: 2, shouldAbort: false });
-    });
-    it("triggers abort on the 3rd consecutive identical failure (session 080fe2fcbf24 case)", () => {
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        const r3 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r3.runLength).toBe(3);
-        expect(r3.shouldAbort).toBe(true);
-    });
-    it("does not re-trigger abort on subsequent identical failures (one-shot latch)", () => {
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        const r3 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r3.shouldAbort).toBe(true);
-        const r4 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r4.runLength).toBe(4);
-        expect(r4.shouldAbort).toBe(false);
-    });
-    it("resets on different input (model is varying the args — that's progress)", () => {
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        const r3 = recordToolError(SID, "grep", { pattern: "different" }, PARSE_ERROR);
-        expect(r3).toEqual({ runLength: 1, shouldAbort: false });
-    });
-    it("resets on different tool name (a different call type is progress)", () => {
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        const r3 = recordToolError(SID, "read_file", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r3).toEqual({ runLength: 1, shouldAbort: false });
-    });
-    it("resets on different error (model may be recovering — let it try)", () => {
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        const r3 = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, "different error — file not found");
-        expect(r3).toEqual({ runLength: 1, shouldAbort: false });
-    });
-    it("isolates sessions (one session's loop does not affect another)", () => {
-        recordToolError("sess-A", "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolError("sess-A", "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        // sess-B is fresh.
-        const r = recordToolError("sess-B", "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r).toEqual({ runLength: 1, shouldAbort: false });
-    });
-    it("no-ops when sessionId is null or empty (utility callers don't crash)", () => {
-        expect(recordToolError(null, "grep", {}, "err")).toEqual({ runLength: 1, shouldAbort: false });
-        expect(recordToolError("", "grep", {}, "err")).toEqual({ runLength: 1, shouldAbort: false });
-        expect(recordToolError(undefined, "grep", {}, "err")).toEqual({ runLength: 1, shouldAbort: false });
-    });
-    it("recordToolSuccess clears the run (mixed success/fail sequence)", () => {
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        recordToolSuccess(SID);
-        const r = recordToolError(SID, "grep", MALFORMED_GREP_ARGS, PARSE_ERROR);
-        expect(r).toEqual({ runLength: 1, shouldAbort: false });
-    });
-    it("buildToolRepetitionAbortMessage includes tool name, run count, and error snippet", () => {
-        const msg = buildToolRepetitionAbortMessage("grep", 3, PARSE_ERROR);
-        expect(msg).toContain('"grep"');
-        expect(msg).toContain("3 times in a row");
-        expect(msg).toContain("JSON parsing failed");
-        expect(msg.length).toBeLessThan(800);
-    });
-    it("buildToolRepetitionAbortMessage truncates and normalizes whitespace in the error preview", () => {
-        const giantErr = `${"x".repeat(2000)}\n\n\nmessy`;
-        const msg = buildToolRepetitionAbortMessage("bash", 5, giantErr);
-        expect(msg).toContain("5 times in a row");
-        expect(msg.length).toBeLessThan(800);
-        expect(msg).not.toMatch(/\n\n+/);
-    });
-});
-//# sourceMappingURL=tool-repetition-detector.test.js.map

package/dist/src/pil/__tests__/budget.test.d.ts

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

package/dist/src/pil/__tests__/budget.test.js

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DEFAULT_TOKEN_BUDGET, truncateToBudget } from "../budget.js";
-describe("truncateToBudget", () => {
-    it("allows ~4 chars per token of budget", () => {
-        const text = "a".repeat(400);
-        const result = truncateToBudget(text, 100);
-        expect(result).toBe(text);
-    });
-    it("truncates text exceeding budget in token-equivalent chars", () => {
-        const text = "a".repeat(500);
-        const result = truncateToBudget(text, 100);
-        expect(result.length).toBeLessThanOrEqual(404);
-    });
-    it("returns short text unchanged", () => {
-        expect(truncateToBudget("hello world", 100)).toBe("hello world");
-    });
-    it("truncates at word boundary when possible", () => {
-        const text = "word ".repeat(120);
-        const result = truncateToBudget(text, 100);
-        expect(result.endsWith("...")).toBe(true);
-        expect(result.length).toBeLessThanOrEqual(404);
-    });
-    it("handles empty string", () => {
-        expect(truncateToBudget("", 100)).toBe("");
-    });
-    it("handles budget=0 by truncating everything", () => {
-        expect(truncateToBudget("hello", 0)).toBe("...");
-    });
-    it("DEFAULT_TOKEN_BUDGET is 500", () => {
-        expect(DEFAULT_TOKEN_BUDGET).toBe(500);
-    });
-});
-//# sourceMappingURL=budget.test.js.map

package/dist/src/pil/__tests__/clarity-gate.test.d.ts

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

package/dist/src/pil/__tests__/clarity-gate.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectNoClarifySignal, hasOperationalScope } from "../clarity-gate.js";
-// Phase 2 (2026-06-16): the regex ASK gate (shouldAutoPass + canInferOutcome +
-// the per-modality scope detectors) was removed — the model now decides every
-// clarification. Only two non-gating helpers survive: detectNoClarifySignal
-// (explicit user consent) and hasOperationalScope (outcome-label polish).
-describe("detectNoClarifySignal()", () => {
-    it("detects explicit no-clarify directives (EN)", () => {
-        expect(detectNoClarifySignal("just answer, don't ask me anything")).toBe(true);
-        expect(detectNoClarifySignal("answer directly without asking")).toBe(true);
-        expect(detectNoClarifySignal("no questions please, just do it")).toBe(true);
-        expect(detectNoClarifySignal("stop asking and give me the result")).toBe(true);
-    });
-    it("detects explicit no-clarify directives (VI + transliteration)", () => {
-        expect(detectNoClarifySignal("Đừng hỏi lại. Trả lời thẳng 3 câu hỏi.")).toBe(true);
-        expect(detectNoClarifySignal("không cần hỏi, trả lời luôn")).toBe(true);
-        expect(detectNoClarifySignal("tra loi thang dung hoi")).toBe(true);
-    });
-    it("does NOT match the explanation idiom 'don't ask me why'", () => {
-        expect(detectNoClarifySignal("it just works, don't ask me why")).toBe(false);
-        expect(detectNoClarifySignal("explain the auth flow")).toBe(false);
-        expect(detectNoClarifySignal("which part of the code should I read?")).toBe(false);
-    });
-});
-describe("hasOperationalScope()", () => {
-    it("detects ci/build/test/action keywords", () => {
-        expect(hasOperationalScope("fix ci fail")).toBe(true);
-        expect(hasOperationalScope("the build is broken")).toBe(true);
-        expect(hasOperationalScope("workflow keeps failing")).toBe(true);
-        expect(hasOperationalScope("gh check shows red")).toBe(true);
-    });
-    it("returns false for unrelated prompts", () => {
-        expect(hasOperationalScope("refactor login flow")).toBe(false);
-        expect(hasOperationalScope("explain hooks")).toBe(false);
-    });
-});
-//# sourceMappingURL=clarity-gate.test.js.map

package/dist/src/pil/__tests__/config.test.d.ts

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

package/dist/src/pil/__tests__/config.test.js

@@ -1,57 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { getMaxInterviewQuestions, isDiscoveryEnabled, isUnifiedPilEnabled } from "../config.js";
-describe("isUnifiedPilEnabled", () => {
-    const orig = process.env.MUONROI_PIL_UNIFIED;
-    beforeEach(() => {
-        delete process.env.MUONROI_PIL_UNIFIED;
-    });
-    afterEach(() => {
-        if (orig === undefined)
-            delete process.env.MUONROI_PIL_UNIFIED;
-        else
-            process.env.MUONROI_PIL_UNIFIED = orig;
-    });
-    it("returns false by default (rollout phase)", () => {
-        expect(isUnifiedPilEnabled()).toBe(false);
-    });
-    it("returns true when MUONROI_PIL_UNIFIED=1", () => {
-        process.env.MUONROI_PIL_UNIFIED = "1";
-        expect(isUnifiedPilEnabled()).toBe(true);
-    });
-    it("returns false when MUONROI_PIL_UNIFIED=0", () => {
-        process.env.MUONROI_PIL_UNIFIED = "0";
-        expect(isUnifiedPilEnabled()).toBe(false);
-    });
-    it("returns false for any other value", () => {
-        process.env.MUONROI_PIL_UNIFIED = "yes";
-        expect(isUnifiedPilEnabled()).toBe(false);
-    });
-});
-describe("isDiscoveryEnabled()", () => {
-    it("returns true by default (no env)", () => {
-        delete process.env.MUONROI_PIL_DISCOVERY;
-        expect(isDiscoveryEnabled()).toBe(true);
-    });
-    it("returns false when MUONROI_PIL_DISCOVERY=0", () => {
-        process.env.MUONROI_PIL_DISCOVERY = "0";
-        expect(isDiscoveryEnabled()).toBe(false);
-        delete process.env.MUONROI_PIL_DISCOVERY;
-    });
-    it("returns true when MUONROI_PIL_DISCOVERY=1", () => {
-        process.env.MUONROI_PIL_DISCOVERY = "1";
-        expect(isDiscoveryEnabled()).toBe(true);
-        delete process.env.MUONROI_PIL_DISCOVERY;
-    });
-});
-describe("getMaxInterviewQuestions()", () => {
-    it("returns 3 by default", () => {
-        delete process.env.MUONROI_PIL_MAX_QUESTIONS;
-        expect(getMaxInterviewQuestions()).toBe(3);
-    });
-    it("respects valid override", () => {
-        process.env.MUONROI_PIL_MAX_QUESTIONS = "2";
-        expect(getMaxInterviewQuestions()).toBe(2);
-        delete process.env.MUONROI_PIL_MAX_QUESTIONS;
-    });
-});
-//# sourceMappingURL=config.test.js.map

package/dist/src/pil/__tests__/discovery-cache.test.d.ts

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

package/dist/src/pil/__tests__/discovery-cache.test.js

@@ -1,38 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { clearDiscoveryCache, getCachedProjectContext, setCachedProjectContext } from "../discovery-cache.js";
-const EMPTY_CTX = {
-    language: "typescript",
-    framework: "next",
-    packageManager: "bun",
-    domain: null,
-    boundedContexts: [],
-    eePatterns: [],
-    relevantModules: [],
-    scannedAt: Date.now(),
-    cwd: "/proj",
-};
-afterEach(() => clearDiscoveryCache());
-describe("discovery-cache", () => {
-    it("returns null when empty", () => {
-        expect(getCachedProjectContext("/proj")).toBeNull();
-    });
-    it("returns cached context for same cwd", () => {
-        setCachedProjectContext(EMPTY_CTX);
-        expect(getCachedProjectContext("/proj")).toEqual(EMPTY_CTX);
-    });
-    it("returns null for different cwd", () => {
-        setCachedProjectContext(EMPTY_CTX);
-        expect(getCachedProjectContext("/other")).toBeNull();
-    });
-    it("returns null after TTL expires", () => {
-        const old = { ...EMPTY_CTX, scannedAt: Date.now() - 6 * 60_000 };
-        setCachedProjectContext(old);
-        expect(getCachedProjectContext("/proj")).toBeNull();
-    });
-    it("clearDiscoveryCache resets", () => {
-        setCachedProjectContext(EMPTY_CTX);
-        clearDiscoveryCache();
-        expect(getCachedProjectContext("/proj")).toBeNull();
-    });
-});
-//# sourceMappingURL=discovery-cache.test.js.map

package/dist/src/pil/__tests__/discovery-types.test.d.ts

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

package/dist/src/pil/__tests__/discovery-types.test.js

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-describe("discovery-types", () => {
-    it("ProjectContext is structurally valid", () => {
-        const ctx = {
-            language: "typescript",
-            framework: "next",
-            packageManager: "bun",
-            domain: "web",
-            boundedContexts: [
-                { path: "src/auth/", name: "auth", entryFiles: ["src/auth/index.ts"], exportedSymbols: ["login"] },
-            ],
-            eePatterns: ["jwt-validation"],
-            relevantModules: [{ path: "src/auth/jwt.ts", relevance: "matches keyword auth", exists: true }],
-            scannedAt: Date.now(),
-            cwd: "/tmp/proj",
-        };
-        expect(ctx.language).toBe("typescript");
-    });
-    it("ModelCard has all required fields", () => {
-        const card = {
-            question: "What auth method?",
-            options: [
-                { label: "OAuth", kind: "choice", isCancel: false, isAdjust: false },
-                { label: "API keys", kind: "choice" },
-                { label: "Custom", kind: "freetext" },
-            ],
-            defaultIndex: 0,
-        };
-        expect(card.question).toBe("What auth method?");
-        expect(card.options).toHaveLength(3);
-    });
-    it("DiscoveryResult has all required fields including interviewTranscript", () => {
-        const result = {
-            raw: "fix auth",
-            projectContext: {
-                language: null,
-                framework: null,
-                packageManager: null,
-                domain: null,
-                boundedContexts: [],
-                eePatterns: [],
-                relevantModules: [],
-                scannedAt: 0,
-                cwd: "",
-            },
-            clarifiedIntent: { outcome: "", scope: [], constraints: [], gaps: [] },
-            feasibility: { viable: true, warnings: [], adjustedScope: [] },
-            interviewed: false,
-            intentStatement: "",
-            outcome: "",
-            scope: [],
-            feasibilityWarnings: [],
-            accepted: true,
-            taskType: "debug",
-            confidence: 0.9,
-            domain: "typescript",
-            outputStyle: "balanced",
-            discoveryMs: 100,
-            interviewTranscript: [],
-        };
-        expect(result.accepted).toBe(true);
-        expect(result.interviewTranscript).toEqual([]);
-    });
-});
-//# sourceMappingURL=discovery-types.test.js.map

package/dist/src/pil/__tests__/discovery.test.d.ts

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