muonroi-cli 1.8.0 → 1.8.3

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 {};

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

@@ -1,178 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-vi.mock("../../ee/bridge.js", () => ({
-    searchByText: vi.fn().mockResolvedValue([]),
-}));
-import { runDiscovery } from "../discovery.js";
-import { clearDiscoveryCache } from "../discovery-cache.js";
-afterEach(() => clearDiscoveryCache());
-const mockHandler = {
-    askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" }),
-};
-describe("runDiscovery()", () => {
-    it("proceeds without interview when the model proposes no cards", async () => {
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-        };
-        const proposer = vi.fn().mockResolvedValue([]);
-        const result = await runDiscovery("fix TypeError in src/auth/login.ts:42", {
-            taskType: "debug",
-            confidence: 0.9,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: "balanced",
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(proposer).toHaveBeenCalled();
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-        expect(handler.askQuestion).not.toHaveBeenCalled();
-    });
-    it("does NOT interview when no proposer is wired", async () => {
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-        };
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, null);
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-        expect(handler.askQuestion).not.toHaveBeenCalled();
-    });
-    it("interviews user when the model proposes cards", async () => {
-        const askQuestion = vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" });
-        const handler = { askQuestion };
-        const modelCards = [
-            {
-                question: "What outcome do you expect?",
-                options: [
-                    { label: "Error disappears", kind: "choice" },
-                    { label: "Not sure", kind: "freetext" },
-                ],
-                defaultIndex: 0,
-            },
-        ];
-        const proposer = vi.fn().mockResolvedValue(modelCards);
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.interviewed).toBe(true);
-        expect(result.accepted).toBe(true);
-        expect(handler.askQuestion).toHaveBeenCalled();
-        expect(result.interviewTranscript).toHaveLength(1);
-        expect(result.interviewTranscript[0].question).toBe("What outcome do you expect?");
-        expect(result.interviewTranscript[0].answer).toBe("Error disappears");
-    });
-    it("records multiple cards in the interview transcript", async () => {
-        const askQuestion = vi
-            .fn()
-            .mockResolvedValueOnce({ questionId: "q1", text: "OAuth", kind: "choice" })
-            .mockResolvedValueOnce({ questionId: "q2", text: "src/auth/", kind: "choice" });
-        const handler = { askQuestion };
-        const modelCards = [
-            {
-                question: "Which auth method?",
-                options: [
-                    { label: "OAuth", kind: "choice" },
-                    { label: "API Keys", kind: "choice" },
-                ],
-                defaultIndex: 0,
-            },
-            {
-                question: "Which module?",
-                options: [
-                    { label: "src/auth/", kind: "choice" },
-                    { label: "src/user/", kind: "choice" },
-                ],
-                defaultIndex: 0,
-            },
-        ];
-        const proposer = vi.fn().mockResolvedValue(modelCards);
-        const result = await runDiscovery("add authentication", {
-            taskType: "generate",
-            confidence: 0.6,
-            complexity: "low",
-            domain: null,
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.interviewTranscript).toHaveLength(2);
-        expect(result.interviewTranscript[0].question).toBe("Which auth method?");
-        expect(result.interviewTranscript[0].answer).toBe("OAuth");
-        expect(result.interviewTranscript[1].question).toBe("Which module?");
-        expect(result.interviewTranscript[1].answer).toBe("src/auth/");
-    });
-    it("sets accepted=false when user picks a cancel option", async () => {
-        const askQuestion = vi
-            .fn()
-            .mockResolvedValueOnce({ questionId: "q1", text: "Cancel this request", kind: "choice" });
-        const handler = { askQuestion };
-        const modelCards = [
-            {
-                question: "What outcome?",
-                options: [
-                    { label: "Proceed", kind: "choice" },
-                    { label: "Cancel this request", kind: "choice", isCancel: true },
-                ],
-                defaultIndex: 0,
-            },
-        ];
-        const proposer = vi.fn().mockResolvedValue(modelCards);
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.accepted).toBe(false);
-    });
-    it("skips all discovery when the user explicitly says don't ask (EN + VI)", async () => {
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-        };
-        const l1 = {
-            taskType: "analyze",
-            confidence: 0.6,
-            complexity: "low",
-            domain: null,
-            outputStyle: null,
-            intentKind: "task",
-        };
-        const enResult = await runDiscovery("analyze the orchestrator, just answer, don't ask", l1, process.cwd(), handler);
-        expect(enResult.interviewed).toBe(false);
-        expect(enResult.accepted).toBe(true);
-        const viResult = await runDiscovery("phân tích orchestrator, đừng hỏi, trả lời thẳng", l1, process.cwd(), handler);
-        expect(viResult.interviewed).toBe(false);
-        expect(viResult.accepted).toBe(true);
-        expect(handler.askQuestion).not.toHaveBeenCalled();
-    });
-    it("skips interview but still passes when handler is null (headless)", async () => {
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), null);
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-    });
-    it("skips discovery entirely for chitchat", async () => {
-        const result = await runDiscovery("hi", { taskType: null, confidence: 0.5, complexity: "low", domain: null, outputStyle: null, intentKind: "chitchat" }, process.cwd(), mockHandler);
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-    });
-});
-//# sourceMappingURL=discovery.test.js.map

package/dist/src/pil/__tests__/dual-run.test.d.ts

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

package/dist/src/pil/__tests__/dual-run.test.js

@@ -1,51 +0,0 @@
-// Dual-run validator: ensures legacy and unified paths produce equivalent
-// classifications on a representative fixture set. Divergence > 10% fails.
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Stub the EE bridge so both legacy and unified paths behave identically
-// in CI (no experience-engine server available). Without this, unified=1
-// triggers a real HTTP call that either times out (exceeding the 200ms pipeline
-// timeout) or returns null — producing different taskType results from legacy=0,
-// which skips the HTTP call entirely.
-vi.mock("../../ee/bridge.js", () => ({
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    routeTask: vi.fn().mockResolvedValue(null),
-    pilContext: vi.fn().mockResolvedValue(null),
-    getWhoAmIProfile: vi.fn(() => null),
-    outputStyleFromProfile: vi.fn(() => null),
-}));
-const FIXTURES = [
-    "tại sao test fail?",
-    "refactor this function",
-    "thiết kế hệ thống auth cho team 3 người",
-    "hi",
-    "fix the bug in login flow",
-    "explain this regex /^\\d+$/",
-    "write docs for the API endpoint",
-    "generate a TypeScript Zod schema for User",
-    "phân tích lỗi memory leak trong service",
-    "ok thanks",
-];
-describe("Dual-run: unified vs legacy", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    it("classification matches in ≥90% of fixtures", async () => {
-        process.env.MUONROI_PIL_UNIFIED = "0";
-        const { runPipeline: runLegacy } = await import("../pipeline.js");
-        const legacyResults = await Promise.all(FIXTURES.map((p) => runLegacy(p)));
-        vi.resetModules();
-        process.env.MUONROI_PIL_UNIFIED = "1";
-        const { runPipeline: runUnified } = await import("../pipeline.js");
-        const unifiedResults = await Promise.all(FIXTURES.map((p) => runUnified(p)));
-        let matches = 0;
-        for (let i = 0; i < FIXTURES.length; i++) {
-            if (legacyResults[i].taskType === unifiedResults[i].taskType)
-                matches++;
-        }
-        const matchRate = matches / FIXTURES.length;
-        expect(matchRate).toBeGreaterThanOrEqual(0.9);
-    });
-});
-//# sourceMappingURL=dual-run.test.js.map

package/dist/src/pil/__tests__/layer1-intent-trace.test.d.ts

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