muonroi-cli 1.4.1 → 1.5.0

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

@@ -1,213 +1,28 @@
 import { describe, expect, it } from "vitest";
-import { canInferOutcome, countFileReferences, hasExplicitScope, hasExternalInfoScope, hasImageScope, hasOperationalScope, hasSelfContainedComputationScope, hasWholeRepoScope, shouldAutoPass, } from "../clarity-gate.js";
-describe("hasWholeRepoScope()", () => {
-    it("detects whole-repo / whole-project intent (EN + VI)", () => {
-        // The repo-eval prompt that fired a nonsensical "which part?" askcard.
-        expect(hasWholeRepoScope("đánh giá repo muonroi-cli này: điểm mạnh, điểm yếu")).toBe(true);
-        expect(hasWholeRepoScope("evaluate the repo: strengths and weaknesses")).toBe(true);
-        expect(hasWholeRepoScope("review the whole codebase")).toBe(true);
-        expect(hasWholeRepoScope("audit the entire project")).toBe(true);
-        expect(hasWholeRepoScope("phân tích toàn bộ dự án")).toBe(true);
-        expect(hasWholeRepoScope("give me an overview of the repository")).toBe(true);
-        // summarize/overview verbs (gap found in the deepseek session probe: "tóm tắt
-        // repo này" still fired the scope askcard because the verb list lacked it).
-        expect(hasWholeRepoScope("tóm tắt nhanh repo này")).toBe(true);
-        expect(hasWholeRepoScope("summarize the repository")).toBe(true);
-        expect(hasWholeRepoScope("give me a summary of the project")).toBe(true);
-    });
-    it("does NOT fire on summarize/review of a narrow target", () => {
-        expect(hasWholeRepoScope("summarize the login function")).toBe(false);
-        expect(hasWholeRepoScope("tóm tắt hàm xử lý auth")).toBe(false);
-    });
-    it("does NOT fire on narrow tasks that merely mention a repo/project", () => {
-        // "this repo" without a wholeness/eval signal must still be scoped.
-        expect(hasWholeRepoScope("add a logout button to this repo")).toBe(false);
-        expect(hasWholeRepoScope("fix the login bug in the project")).toBe(false);
-        expect(hasWholeRepoScope("implement the search feature")).toBe(false);
-        expect(hasWholeRepoScope("refactor the auth module")).toBe(false);
-    });
-    it("whole-repo scope no longer blocks auto-pass (was: scope-gap → false)", () => {
-        // With an inferable outcome (explicit goal), the ONLY remaining blocker for a
-        // repo-wide prompt was the scope gap. hasWholeRepoScope clears it.
-        const prompt = "review the entire codebase — goal: a report of strengths and weaknesses";
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, prompt)).toBe(true);
-        // Control: same shape but NOT repo-wide still fails on the scope gap.
-        const narrow = "review the system — goal: a report of strengths and weaknesses";
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, narrow)).toBe(false);
-    });
-});
-describe("hasSelfContainedComputationScope()", () => {
-    it("detects an inline-data computation prompt (the operand is in the prompt, not the codebase)", () => {
-        // Live drive (deepseek-vs-grok A/B, session probe 2026-06-05): "Compute
-        // f([3,1,2]) where f sorts the list ascending then returns the sum of the
-        // first two elements." classified taskType=analyze (regex:read matched the
-        // bare word "list") fired the codebase-scope askcard "Which part of the
-        // codebase should this target?" — nonsensical for a self-contained math
-        // problem whose input data is supplied inline. Symmetric to image/web/
-        // operational scope guards.
-        expect(hasSelfContainedComputationScope("Compute f([3,1,2]) where f sorts the list ascending then returns the sum of the first two elements.")).toBe(true);
-        expect(hasSelfContainedComputationScope("Given the array [5, 2, 8, 1, 9], what is the second largest element?")).toBe(true);
-        expect(hasSelfContainedComputationScope("What is the median of [10, 4, 7]?")).toBe(true);
-        expect(hasSelfContainedComputationScope('Reverse the list ["a", "b", "c"] and return it.')).toBe(true);
-    });
-    it("does NOT fire without an inline data literal", () => {
-        // The framing verb alone is not enough — a codebase task can say "compute"
-        // ("compute the hash in the auth module"). Only an inline operand qualifies.
-        expect(hasSelfContainedComputationScope("compute the cache key in the auth module")).toBe(false);
-        expect(hasSelfContainedComputationScope("sort the users table by created_at")).toBe(false);
-        expect(hasSelfContainedComputationScope("what is the second largest element of the array")).toBe(false);
-    });
-    it("does NOT fire on a real codebase task that merely contains an array literal (no compute framing)", () => {
-        // Narrowness guard: the literal alone is not enough. A feature/debug task
-        // that embeds a literal but is scoped to the codebase must KEEP its scope
-        // askcard. Requires BOTH an inline literal AND computation framing.
-        expect(hasSelfContainedComputationScope("add the items [1, 2, 3] to the cart in the checkout flow")).toBe(false);
-        expect(hasSelfContainedComputationScope("fix the bug where parseRange([1, 5]) returns the wrong values")).toBe(false);
-        expect(hasSelfContainedComputationScope("set the default retry delays to [100, 200, 400] in the config")).toBe(false);
-    });
-    it("does NOT fire on bracketed file-name lists (those are codebase-scoped)", () => {
-        // [a.ts, b.ts] is a list of files, not data — must stay codebase-scoped.
-        expect(hasSelfContainedComputationScope("compare the exports of [auth.ts, session.ts]")).toBe(false);
-    });
-    it("self-contained computation no longer blocks auto-pass (was: scope-gap → false)", () => {
-        // With an inferable outcome ("return the result"), the ONLY remaining blocker
-        // for an inline-data computation prompt was the scope gap.
-        // hasSelfContainedComputationScope clears it.
-        const prompt = "Compute the sum of the first two sorted elements of [3, 1, 2] and return the result.";
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, prompt)).toBe(true);
-        // Control: same outcome-inferable shape but NO inline literal still fails on
-        // the scope gap (a real codebase computation must still be scoped).
-        const codeTask = "Compute the largest element of the users array and return it.";
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, codeTask)).toBe(false);
-    });
-});
-describe("canInferOutcome()", () => {
-    it("returns false for null taskType", () => {
-        expect(canInferOutcome(null, "do something")).toBe(false);
-    });
-    it("returns false for general taskType", () => {
-        expect(canInferOutcome("general", "fix stuff")).toBe(false);
-    });
-    it("returns true for a general taskType that is a direct imperative command", () => {
-        // A direct command has a self-evident outcome (it runs / it shows), so it
-        // should auto-pass instead of triggering an outcome-clarification askcard.
-        expect(canInferOutcome("general", "run the test suite")).toBe(true);
-        expect(canInferOutcome("general", "echo harness-ok")).toBe(true);
-        expect(canInferOutcome("general", "show the package.json scripts")).toBe(true);
-        expect(canInferOutcome("general", "list the open ports")).toBe(true);
-    });
-    it("returns false for a general imperative verb with no object", () => {
-        expect(canInferOutcome("general", "run")).toBe(false);
-        expect(canInferOutcome("general", "execute   ")).toBe(false);
-    });
-    it("returns false for a general non-imperative prompt", () => {
-        expect(canInferOutcome("general", "the build is slow")).toBe(false);
-    });
-    it("returns true when prompt has error reference", () => {
-        expect(canInferOutcome("debug", "fix the TypeError in login")).toBe(true);
-    });
-    it("returns true when prompt has file:line reference", () => {
-        expect(canInferOutcome("debug", "fix auth.ts:42")).toBe(true);
-    });
-    it("returns true when prompt has target state verb", () => {
-        expect(canInferOutcome("refactor", "should return a Promise")).toBe(true);
-    });
-    it("returns true when prompt has add pattern", () => {
-        expect(canInferOutcome("generate", "add validation to login form")).toBe(true);
-    });
-    it("returns false for vague prompt with valid taskType", () => {
-        expect(canInferOutcome("debug", "fix auth")).toBe(false);
-    });
-});
-describe("countFileReferences()", () => {
-    it("counts .ts and .tsx files", () => {
-        expect(countFileReferences("fix login.ts and dashboard.tsx")).toBe(2);
-    });
-    it("returns 0 for no file refs", () => {
-        expect(countFileReferences("fix the auth module")).toBe(0);
-    });
-    it("ignores non-code extensions", () => {
-        expect(countFileReferences("see report.pdf")).toBe(0);
-    });
-});
-describe("hasExplicitScope()", () => {
-    it("detects src/ paths", () => {
-        expect(hasExplicitScope("refactor src/auth/jwt.ts")).toBe(true);
-    });
-    it("detects lib/ paths", () => {
-        expect(hasExplicitScope("update lib/utils")).toBe(true);
-    });
-    it("returns false for no path", () => {
-        expect(hasExplicitScope("refactor the code")).toBe(false);
-    });
-});
-describe("shouldAutoPass()", () => {
-    it("auto-passes high-confidence + specific file + inferrable outcome", () => {
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "debug", complexity: "low" }, "fix TypeError in src/auth/login.ts:42")).toBe(true);
-    });
-    it("rejects low confidence", () => {
-        expect(shouldAutoPass({ confidence: 0.6, taskType: "debug", complexity: "low" }, "fix TypeError in login.ts:42")).toBe(false);
-    });
-    it("rejects vague prompt despite high confidence", () => {
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "debug", complexity: "low" }, "fix auth")).toBe(false);
-    });
-    it("rejects high complexity", () => {
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "refactor", complexity: "high" }, "refactor src/auth/login.ts should return Promise")).toBe(false);
-    });
-    it("auto-passes with explicit scope path even without file extension", () => {
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "refactor", complexity: "medium" }, "refactor src/auth/ module to return Promises")).toBe(true);
-    });
-    // PIL-L6 fix
-    it("auto-passes CI/build debug task even without file path (operational scope)", () => {
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "debug", complexity: "low" }, "fix the ci fail — goal: green pipeline")).toBe(true);
-    });
-    // Image-scope fix — an image-analysis task is scoped to the image, not a file
-    // path, so it should auto-pass when its outcome is inferrable.
-    it("auto-passes an image-analysis task even without file path (image scope)", () => {
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, "analyze screenshot.png — goal: describe the layout")).toBe(true);
-    });
-    // External-info fix — a web-search task is scoped to the web, not a file path.
-    it("auto-passes a web-search task even without file path (external-info scope)", () => {
-        expect(shouldAutoPass({ confidence: 0.9, taskType: "analyze", complexity: "low" }, "search the web for the vitest release date — goal: find the version")).toBe(true);
-    });
-});
-describe("hasExternalInfoScope()", () => {
-    it("detects web-search / external-info intent", () => {
-        expect(hasExternalInfoScope("search the web for the latest vitest release notes")).toBe(true);
-        expect(hasExternalInfoScope("google the error message")).toBe(true);
-        expect(hasExternalInfoScope("what's the latest news on the framework")).toBe(true);
-        expect(hasExternalInfoScope("summarize https://example.com/post")).toBe(true);
-    });
-    it("returns false for codebase tasks, including in-repo 'search'", () => {
-        // Narrow: must NOT swallow a real code task. "search the codebase" and
-        // "search feature" are codebase work and still deserve a scope askcard.
-        expect(hasExternalInfoScope("search the codebase for usages of foo")).toBe(false);
-        expect(hasExternalInfoScope("implement the search feature")).toBe(false);
-        expect(hasExternalInfoScope("add the zod library to the auth module")).toBe(false);
-        expect(hasExternalInfoScope("refactor the login flow")).toBe(false);
-    });
-});
-describe("hasImageScope()", () => {
-    it("detects an image file extension", () => {
-        expect(hasImageScope("analyze diagram.png")).toBe(true);
-        expect(hasImageScope("describe the layout of mock.jpg")).toBe(true);
-        expect(hasImageScope("read chart.svg")).toBe(true);
-    });
-    it("detects a data:image URI and screenshot/photo nouns", () => {
-        expect(hasImageScope("here is data:image/png;base64,AAAA")).toBe(true);
-        expect(hasImageScope("take a screenshot and analyze it")).toBe(true);
-        expect(hasImageScope("look at the photo")).toBe(true);
-    });
-    it("returns false for codebase tasks and ambiguous/overloaded words", () => {
-        // Narrow on purpose: a false positive SUPPRESSES a legitimate scope
-        // question, so overloaded words must NOT match.
-        expect(hasImageScope("refactor the login flow")).toBe(false);
-        expect(hasImageScope("add a logo to the header")).toBe(false); // "logo" excluded
-        expect(hasImageScope("rebuild the docker image")).toBe(false); // bare "image" excluded
-        expect(hasImageScope("look at the bigger picture")).toBe(false); // "picture" excluded
-    });
-});
-describe("hasOperationalScope() — PIL-L6", () => {
+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);
@@ -219,10 +34,4 @@ describe("hasOperationalScope() — PIL-L6", () => {
         expect(hasOperationalScope("explain hooks")).toBe(false);
     });
 });
-describe("canInferOutcome() — explicit goal (PIL-L6)", () => {
-    it("returns true when prompt names an explicit goal", () => {
-        expect(canInferOutcome("debug", "goal: pipeline green")).toBe(true);
-        expect(canInferOutcome("debug", "mong muốn: tests passing")).toBe(true);
-    });
-});
 //# sourceMappingURL=clarity-gate.test.js.map

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { getAutoPassThreshold, getMaxInterviewQuestions, isDiscoveryEnabled, isUnifiedPilEnabled } from "../config.js";
+import { getMaxInterviewQuestions, isDiscoveryEnabled, isUnifiedPilEnabled } from "../config.js";
 describe("isUnifiedPilEnabled", () => {
     const orig = process.env.MUONROI_PIL_UNIFIED;
     beforeEach(() => {
@@ -43,22 +43,6 @@ describe("isDiscoveryEnabled()", () => {
         delete process.env.MUONROI_PIL_DISCOVERY;
     });
 });
-describe("getAutoPassThreshold()", () => {
-    it("returns 0.85 by default", () => {
-        delete process.env.MUONROI_PIL_AUTOPASS_THRESHOLD;
-        expect(getAutoPassThreshold()).toBe(0.85);
-    });
-    it("respects env override in range", () => {
-        process.env.MUONROI_PIL_AUTOPASS_THRESHOLD = "0.7";
-        expect(getAutoPassThreshold()).toBe(0.7);
-        delete process.env.MUONROI_PIL_AUTOPASS_THRESHOLD;
-    });
-    it("clamps out-of-range to default", () => {
-        process.env.MUONROI_PIL_AUTOPASS_THRESHOLD = "1.5";
-        expect(getAutoPassThreshold()).toBe(0.85);
-        delete process.env.MUONROI_PIL_AUTOPASS_THRESHOLD;
-    });
-});
 describe("getMaxInterviewQuestions()", () => {
     it("returns 3 by default", () => {
         delete process.env.MUONROI_PIL_MAX_QUESTIONS;

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

@@ -10,7 +10,14 @@ const mockHandler = {
     showAcceptance: vi.fn().mockResolvedValue("accept"),
 };
 describe("runDiscovery()", () => {
-    it("auto-passes on high-confidence specific prompt", async () => {
+    it("proceeds without interview when the model proposes no questions", async () => {
+        // Phase 2: the model is the sole ask-decider. An empty proposer result means
+        // "no gray area" → no interview, no fabricated [Discovery] outcome.
+        const handler = {
+            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
+            showAcceptance: vi.fn().mockResolvedValue("accept"),
+        };
+        const proposer = vi.fn().mockResolvedValue([]);
         const result = await runDiscovery("fix TypeError in src/auth/login.ts:42", {
             taskType: "debug",
             confidence: 0.9,
@@ -18,15 +25,86 @@ describe("runDiscovery()", () => {
             domain: "typescript",
             outputStyle: "balanced",
             intentKind: "task",
-        }, process.cwd(), null);
+        }, process.cwd(), handler, null, proposer);
+        expect(proposer).toHaveBeenCalled();
         expect(result.interviewed).toBe(false);
         expect(result.accepted).toBe(true);
+        expect(handler.askQuestion).not.toHaveBeenCalled();
     });
-    it("interviews user on vague prompt with handler", async () => {
+    it("does NOT interview (and never fabricates regex questions) when no proposer is wired", async () => {
+        // Phase 2 fail-loud: an interactive turn missing a proposer logs and proceeds
+        // WITHOUT an interview — it must never fall back to keyword-generated gaps.
+        const handler = {
+            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
+            showAcceptance: vi.fn().mockResolvedValue("accept"),
+        };
+        const result = await runDiscovery("fix auth", // vague — old regex gate would have asked a scope question
+        {
+            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("surfaces the model's reason + recommends in the interview askcard", async () => {
+        const askQuestion = vi.fn().mockResolvedValue({ questionId: "q1", text: "OAuth", kind: "choice" });
+        const handler = {
+            askQuestion,
+            showAcceptance: vi.fn().mockResolvedValue("accept"),
+        };
+        const proposer = vi
+            .fn()
+            .mockResolvedValue(["Which auth method? [MODEL RECS: OAuth | API keys] [WHY: changes the whole token flow]"]);
+        await runDiscovery("add authentication", {
+            taskType: "generate",
+            confidence: 0.6,
+            complexity: "low",
+            domain: null,
+            outputStyle: null,
+            intentKind: "task",
+        }, process.cwd(), handler, null, proposer);
+        expect(askQuestion).toHaveBeenCalled();
+        const card = askQuestion.mock.calls[0][0];
+        // Model's WHY drives the askcard context; recommends drive the options.
+        expect(card.context).toBe("changes the whole token flow");
+        expect(card.question).toBe("Which auth method?");
+        const labels = (card.options ?? []).map((o) => o.label);
+        expect(labels).toContain("OAuth");
+        expect(labels).toContain("API keys");
+        expect(card.defaultIndex).toBe(0); // first recommend = recommended default
+    });
+    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" }),
+            showAcceptance: vi.fn().mockResolvedValue("accept"),
+        };
+        const l1 = {
+            taskType: "analyze",
+            confidence: 0.6, // low enough that discovery would normally interview
+            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("interviews user when the model proposes a question", async () => {
         const handler = {
             askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" }),
             showAcceptance: vi.fn().mockResolvedValue("accept"),
         };
+        const proposer = vi.fn().mockResolvedValue(["What's the expected fix outcome? [MODEL RECS: Error disappears]"]);
         const result = await runDiscovery("fix auth", {
             taskType: "debug",
             confidence: 0.6,
@@ -34,7 +112,7 @@ describe("runDiscovery()", () => {
             domain: "typescript",
             outputStyle: null,
             intentKind: "task",
-        }, process.cwd(), handler);
+        }, process.cwd(), handler, null, proposer);
         expect(result.interviewed).toBe(true);
         expect(result.accepted).toBe(true);
         expect(handler.askQuestion).toHaveBeenCalled();
@@ -53,14 +131,14 @@ describe("runDiscovery()", () => {
     });
     it("sets accepted=false when user cancels", async () => {
         const handler = {
-            // PIL-L6 fix — debug now autofills outcome, so only the scope gap is
-            // asked. First call = scope gap, second call = acceptance card.
+            // First askQuestion = the model's interview question, second = acceptance card.
             askQuestion: vi
                 .fn()
                 .mockResolvedValueOnce({ questionId: "q1", text: "done", kind: "choice" })
                 .mockResolvedValue({ questionId: "q-acc", text: "cancel", kind: "choice" }),
             showAcceptance: vi.fn().mockResolvedValue("cancel"),
         };
+        const proposer = vi.fn().mockResolvedValue(["What's the expected outcome? [MODEL RECS: Error disappears]"]);
         const result = await runDiscovery("fix auth", {
             taskType: "debug",
             confidence: 0.6,
@@ -68,17 +146,18 @@ describe("runDiscovery()", () => {
             domain: "typescript",
             outputStyle: null,
             intentKind: "task",
-        }, process.cwd(), handler);
+        }, process.cwd(), handler, null, proposer);
         expect(result.accepted).toBe(false);
     });
     it("does not swallow the original request into a generic outcome for a general prompt (B2)", async () => {
-        // B2 — answering the (now-skipped) generic outcome askcard used to collapse
-        // the intent to "general: Task completed", discarding the user's prompt.
-        // The scope gap may still fire; the outcome must derive from the raw text.
+        // B2 — the old generic outcome askcard collapsed intent to "general: Task
+        // completed", discarding the user's prompt. With the model proposing no
+        // questions, the outcome must derive from the raw text (no fabrication).
         const handler = {
             askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Task completed", kind: "choice" }),
             showAcceptance: vi.fn().mockResolvedValue("accept"),
         };
+        const proposer = vi.fn().mockResolvedValue([]);
         const result = await runDiscovery("make the dashboard feel less cluttered", {
             taskType: "general",
             confidence: 0.6,
@@ -86,7 +165,7 @@ describe("runDiscovery()", () => {
             domain: null,
             outputStyle: null,
             intentKind: "task",
-        }, process.cwd(), handler);
+        }, process.cwd(), handler, null, proposer);
         expect(result.intentStatement).not.toBe("general: Task completed");
         expect(result.outcome).not.toBe("Task completed");
         // The original request must survive into the resolved outcome.
@@ -98,4 +177,58 @@ describe("runDiscovery()", () => {
         expect(result.accepted).toBe(true);
     });
 });
+describe("runDiscovery() — outcome autofill override (path-leak vs legit slash)", () => {
+    const analyzeL1 = {
+        taskType: "analyze",
+        confidence: 0.6,
+        complexity: "low",
+        domain: null,
+        outputStyle: null,
+        intentKind: "task",
+    };
+    // A handler that always picks `text` for both the interview answer and the
+    // acceptance card (any non-"cancel"/"adjust" text accepts).
+    const pickAnswer = (text) => ({
+        askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text, kind: "choice" }),
+        showAcceptance: vi.fn().mockResolvedValue("accept"),
+    });
+    it("preserves a user outcome answer containing '/' (does not clobber with the autofilled default)", async () => {
+        // Regression: the override matched ANY '/' (bare `\/` regex alt +
+        // `.includes("/")`), silently replacing a legit answer like
+        // "support both REST/GraphQL endpoints" with the analyze default.
+        const userAnswer = "support both REST/GraphQL endpoints";
+        const proposer = vi
+            .fn()
+            .mockResolvedValue([
+            "Which API surface should the analysis target? [MODEL RECS: support both REST/GraphQL endpoints | REST only]",
+        ]);
+        const result = await runDiscovery("review the API layer", analyzeL1, process.cwd(), pickAnswer(userAnswer), null, proposer);
+        expect(result.outcome).toBe(userAnswer);
+        expect(result.outcome).not.toBe("Detailed analysis with concrete improvement recommendations");
+    });
+    it("preserves another 'or'-style slash answer (validate input/output schemas)", async () => {
+        const userAnswer = "validate input/output schemas";
+        const proposer = vi.fn().mockResolvedValue(["What should the analysis verify?"]);
+        const result = await runDiscovery("review the API layer", analyzeL1, process.cwd(), pickAnswer(userAnswer), null, proposer);
+        expect(result.outcome).toBe(userAnswer);
+    });
+    it("still overwrites a genuinely path-leaked outcome with the autofilled default", async () => {
+        // Guard against over-correction: a real filesystem-path leak (scope-option
+        // shape "src/cli (cli)") must STILL be replaced by the inferred outcome.
+        const proposer = vi.fn().mockResolvedValue(["What scope? [MODEL RECS: src/cli (cli)]"]);
+        const result = await runDiscovery("review the API layer", analyzeL1, process.cwd(), pickAnswer("src/cli (cli)"), null, proposer);
+        expect(result.outcome).toBe("Detailed analysis with concrete improvement recommendations");
+    });
+    it("treats the 'provide my own details' meta-option as no-answer, not a literal outcome", async () => {
+        // The default meta-option ("I will provide my own details / constraints")
+        // is a 'no specific answer' sentinel — it must not survive verbatim as the
+        // outcome. With no inferred default available (generate), it falls back to
+        // the raw-derived intent rather than the sentinel string.
+        const sentinel = "I will provide my own details / constraints";
+        const proposer = vi.fn().mockResolvedValue(["What outcome do you expect?"]);
+        const result = await runDiscovery("build the user dashboard widget", { ...analyzeL1, taskType: "generate" }, process.cwd(), pickAnswer(sentinel), null, proposer);
+        expect(result.outcome).not.toBe(sentinel);
+        expect(result.outcome.toLowerCase()).toContain("dashboard");
+    });
+});
 //# sourceMappingURL=discovery.test.js.map

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

@@ -4,18 +4,23 @@
  * pil-report command can answer "which pass actually decided the outcome".
  */
 import { beforeEach, describe, expect, it, vi } from "vitest";
-const { mockClassify, mockClassifyViaBrain, mockPilContext, mockIsUnifiedPilEnabled } = vi.hoisted(() => ({
+const { mockClassify, mockClassifyViaBrain, mockPilContext, mockIsUnifiedPilEnabled, mockIsLlmFirstClassifyEnabled } = vi.hoisted(() => ({
     mockClassify: vi.fn(),
     mockClassifyViaBrain: vi.fn(),
     mockPilContext: vi.fn(),
     mockIsUnifiedPilEnabled: vi.fn(),
+    // OFF so these trace tests exercise the regex cascade passes.
+    mockIsLlmFirstClassifyEnabled: vi.fn(() => false),
 }));
 vi.mock("../../router/classifier/index.js", () => ({ classify: mockClassify }));
 vi.mock("../../ee/bridge.js", () => ({
     classifyViaBrain: mockClassifyViaBrain,
     pilContext: mockPilContext,
 }));
-vi.mock("../config.js", () => ({ isUnifiedPilEnabled: mockIsUnifiedPilEnabled }));
+vi.mock("../config.js", () => ({
+    isUnifiedPilEnabled: mockIsUnifiedPilEnabled,
+    isLlmFirstClassifyEnabled: mockIsLlmFirstClassifyEnabled,
+}));
 import { layer1Intent } from "../layer1-intent.js";
 function makeCtx(raw) {
     return {

package/dist/src/pil/__tests__/layer1-intent.test.js

@@ -4,6 +4,9 @@ vi.mock("../../router/classifier/index.js", () => ({
 }));
 vi.mock("../config.js", () => ({
     isUnifiedPilEnabled: vi.fn(() => false),
+    // OFF here so these cascade tests exercise the regex passes (the model-first
+    // gate is covered in src/pil/layer1-intent.test.ts).
+    isLlmFirstClassifyEnabled: vi.fn(() => false),
 }));
 vi.mock("../../ee/bridge.js", () => ({
     classifyViaBrain: vi.fn().mockResolvedValue(null),