muonroi-cli 1.4.1 → 1.6.0

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),

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

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { buildInterviewQuestion, detectClarityGaps, resolveGapsNonInteractive } from "../layer16-clarity.js";
+import { buildInterviewQuestion, resolveGapsNonInteractive } from "../layer16-clarity.js";
+// Phase 2 (2026-06-16): detectClarityGaps + its keyword option-builders were
+// removed (the model now generates every clarification). The surviving helpers
+// — buildInterviewQuestion (render) and resolveGapsNonInteractive (headless
+// default-answer resolution) — are exercised here with model-shaped gaps.
 const EMPTY_PROJECT = {
     language: "typescript",
     framework: null,
@@ -10,122 +14,10 @@ const EMPTY_PROJECT = {
         { path: "src/billing/", name: "billing", entryFiles: [], exportedSymbols: [] },
     ],
     eePatterns: [],
-    relevantModules: [],
+    relevantModules: [{ path: "src/auth/", relevance: "named in prompt", exists: true }],
     scannedAt: Date.now(),
     cwd: "/proj",
 };
-describe("detectClarityGaps()", () => {
-    it("detects outcome gap for vague non-debug prompt", () => {
-        // PIL-L6 fix — debug now joins the autofill set, so vague debug prompts
-        // ("fix auth") no longer trigger an outcome question. Use a generate
-        // prompt instead to still cover the gap-detection path.
-        const gaps = detectClarityGaps("build something", "generate", 0.7, EMPTY_PROJECT);
-        const outcomeGap = gaps.find((g) => g.dimension === "outcome");
-        expect(outcomeGap).toBeDefined();
-    });
-    it("does NOT detect outcome gap for vague debug prompt (autofilled)", () => {
-        const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
-        const outcomeGap = gaps.find((g) => g.dimension === "outcome");
-        expect(outcomeGap).toBeUndefined();
-    });
-    it("does NOT detect an outcome gap for a vague general prompt (B2 intent-swallow guard)", () => {
-        // B2 — a `general` prompt's only outcome options are tautological
-        // ("Task completed" / "Issue resolved"). Asking them lets the default
-        // answer overwrite the user's real request, so the intent collapses to
-        // "general: Task completed" and the original prompt is lost. Skip the
-        // askcard so the outcome falls back to the raw request downstream.
-        const gaps = detectClarityGaps("the project feels messy", "general", 0.7, EMPTY_PROJECT);
-        const outcomeGap = gaps.find((g) => g.dimension === "outcome");
-        expect(outcomeGap).toBeUndefined();
-    });
-    it("detects scope gap when no file reference", () => {
-        const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
-        const scopeGap = gaps.find((g) => g.dimension === "scope");
-        expect(scopeGap).toBeDefined();
-    });
-    it("returns no gaps for specific prompt", () => {
-        const gaps = detectClarityGaps("fix TypeError in src/auth/login.ts:42", "debug", 0.9, EMPTY_PROJECT);
-        expect(gaps).toHaveLength(0);
-    });
-    it("scope options include matching bounded contexts", () => {
-        const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
-        const scopeGap = gaps.find((g) => g.dimension === "scope");
-        expect(scopeGap?.options.some((o) => o.includes("auth"))).toBe(true);
-    });
-    it("does NOT detect a scope gap for a general prompt with no codebase signal (B2-symmetric scope guard)", () => {
-        // Live drive (session 8a87aa060c6a): the pure non-codebase prompt "Reply
-        // with exactly one word: PONG" fired the scope askcard "Which part of the
-        // codebase should this target?" because countFileReferences /
-        // hasExplicitScope / hasOperationalScope were all empty — the detector
-        // assumes every prompt is a codebase task. A general/unclassified prompt
-        // has no codebase dimension to scope, so the question is nonsensical (and
-        // its acceptance card is downstream noise). Skip it, symmetric to the B2
-        // outcome guard; scope falls back to project-root downstream.
-        const gaps = detectClarityGaps("Reply with exactly one word: PONG", "general", 0.6, EMPTY_PROJECT);
-        expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-        // The only candidate gap was scope → general prompt now yields zero gaps,
-        // so discovery never marks interviewed=true and shows no acceptance card.
-        expect(gaps).toHaveLength(0);
-    });
-    it("STILL detects a scope gap for a classified (non-general) task with no file reference", () => {
-        // Guard must stay narrow: a real code task that simply omitted a path still
-        // benefits from the scope-narrowing askcard. Only general/null is skipped.
-        const gaps = detectClarityGaps("implement the search feature", "generate", 0.7, EMPTY_PROJECT);
-        expect(gaps.find((g) => g.dimension === "scope")).toBeDefined();
-    });
-    it("does NOT detect a scope gap for an image-analysis prompt (image is the scope)", () => {
-        // Live drive (PR#34 probe): "Take a screenshot of the homepage and analyze
-        // the diagram.png image to describe its layout" fired the codebase-scope
-        // askcard "Which part of the codebase should this target?" — nonsensical for
-        // an image-analysis task. The image (screenshot / diagram.png) IS the scope,
-        // symmetric to how operational (CI/build) prompts are scoped to the pipeline.
-        const gaps = detectClarityGaps("Take a screenshot of the homepage and analyze the diagram.png image to describe its layout", "analyze", 0.7, EMPTY_PROJECT);
-        expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-        // analyze autofills outcome, so with scope suppressed there are zero gaps →
-        // no interview, no acceptance card.
-        expect(gaps).toHaveLength(0);
-    });
-    it("STILL detects a scope gap for a code task that mentions an ambiguous non-image word", () => {
-        // Narrowness guard: image-scope suppression must not swallow real codebase
-        // tasks. "add a logo to the header" carries no concrete image signal (no
-        // file extension / screenshot / photo), so the scope askcard stays.
-        const gaps = detectClarityGaps("add a logo to the header", "generate", 0.7, EMPTY_PROJECT);
-        expect(gaps.find((g) => g.dimension === "scope")).toBeDefined();
-    });
-    it("does NOT detect a scope gap for a web-search / external-info prompt", () => {
-        // Live drive (tavily probe, session d7a45a2dba30): "search the web for the
-        // latest vitest release notes" classified taskType=analyze fired the
-        // codebase-scope askcard and recorded a wrong scope ("src/mcp"). A
-        // web-search task is scoped to the web, not the codebase — symmetric to the
-        // image-scope and operational-scope guards.
-        const gaps = detectClarityGaps("search the web for the latest vitest release notes", "analyze", 0.7, EMPTY_PROJECT);
-        expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-        expect(gaps).toHaveLength(0);
-    });
-    it("does NOT detect a scope gap for a self-contained computation prompt (data is inline)", () => {
-        // Live drive (deepseek-vs-grok A/B, session 17fc23f0): "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", conf 0.80 → skipped the brain) fired BOTH the pil-interview scope
-        // askcard ("Which part of the codebase should this target?" → auto "Entire
-        // project") AND the pil-acceptance card. The operand [3,1,2] is supplied
-        // inline — the task has no codebase dimension to scope. Symmetric to the
-        // image / web / operational scope guards.
-        const gaps = detectClarityGaps("Compute f([3,1,2]) where f sorts the list ascending then returns the sum of the first two elements.", "analyze", 0.8, EMPTY_PROJECT);
-        expect(gaps.find((g) => g.dimension === "scope")).toBeUndefined();
-        // analyze autofills outcome, so with scope suppressed there are zero gaps →
-        // no interview, no acceptance card.
-        expect(gaps).toHaveLength(0);
-    });
-    it("STILL detects a scope gap for a code task that embeds a literal but no compute framing", () => {
-        // Narrowness guard: the inline-literal suppression must not swallow real
-        // codebase tasks. "set the default retry delays to [100, 200, 400] in the
-        // config" carries a literal but is scoped to the codebase (no compute verb),
-        // so the scope askcard stays.
-        const gaps = detectClarityGaps("set the default retry delays to [100, 200, 400] in the config", "generate", 0.7, EMPTY_PROJECT);
-        expect(gaps.find((g) => g.dimension === "scope")).toBeDefined();
-    });
-});
 describe("buildInterviewQuestion()", () => {
     it("builds a CouncilQuestionData with pil-interview phase", () => {
         const gap = {
@@ -141,11 +33,35 @@ describe("buildInterviewQuestion()", () => {
         expect(q.options).toBeDefined();
         expect(q.options.some((o) => o.kind === "freetext")).toBe(true);
     });
+    it("surfaces the model's reason (gap.description) as the askcard context", () => {
+        const gap = {
+            dimension: "outcome",
+            description: "answering this changes whether we add OAuth or just API keys",
+            suggestedQuestion: "Which auth method?",
+            options: ["OAuth", "API keys"],
+            defaultIndex: 0,
+        };
+        const q = buildInterviewQuestion(gap, "q-2");
+        expect(q.context).toBe("answering this changes whether we add OAuth or just API keys");
+    });
 });
 describe("resolveGapsNonInteractive()", () => {
-    it("fills gaps with best-effort from project context", () => {
-        const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
+    it("fills gaps with best-effort defaults from the model options + project context", () => {
+        const gaps = [
+            {
+                dimension: "outcome",
+                description: "Model-generated clarification #1",
+                suggestedQuestion: "What outcome do you expect?",
+                options: ["Error resolved", "Other (type free answer)"],
+                defaultIndex: 0,
+            },
+        ];
         const resolved = resolveGapsNonInteractive(gaps, EMPTY_PROJECT, "fix auth");
+        expect(resolved.outcome).toBe("Error resolved");
+        expect(resolved.scope.length).toBeGreaterThan(0);
+    });
+    it("falls back to the raw-derived outcome when there is no outcome gap", () => {
+        const resolved = resolveGapsNonInteractive([], EMPTY_PROJECT, "fix the login bug");
         expect(resolved.outcome).toBeTruthy();
         expect(resolved.scope.length).toBeGreaterThan(0);
     });

package/dist/src/pil/__tests__/layer4-gsd.test.js

@@ -75,6 +75,43 @@ describe("layer4Gsd (gsd-native)", () => {
         const result = await layer4Gsd(makeCtx({ raw: "review the pull request" }));
         expect(["review", "discuss", "execute"]).toContain(result.gsdPhase);
     });
+    it("routes a question-shaped analyze/debug prompt to the QUESTION directive (no 'state a plan')", async () => {
+        // De-robotizing: a plain question must not get the STANDARD "state a 2-3 line
+        // plan" scaffold even when L1 classifies it analyze/debug (not "general").
+        const q = "why does the build fail intermittently?";
+        const result = await layer4Gsd(makeCtx({ raw: q, enriched: q, taskType: "debug", intentKind: "task" }));
+        expect(result.enriched).toContain("QUESTION / explanatory");
+        expect(result.enriched).not.toContain("State a 2-3 line plan");
+    });
+    it("treats a genuine general question (general + task) as informational", async () => {
+        const q = "what does the enrichment layer do?";
+        const result = await layer4Gsd(makeCtx({ raw: q, enriched: q, taskType: "general", intentKind: "task" }));
+        expect(result.enriched).toContain("QUESTION / explanatory");
+    });
+    it("does NOT treat an implementation request as informational even if phrased as a question", async () => {
+        // isImplementationIntent guards the question clause: "can you refactor … and
+        // wire up …" is a real edit task → STANDARD scaffold, not the QUESTION directive.
+        const q = "can you refactor the dropdown and wire up the keyboard handlers?";
+        const result = await layer4Gsd(makeCtx({ raw: q, enriched: q, taskType: "refactor", intentKind: "task" }));
+        expect(result.enriched).not.toContain("QUESTION / explanatory");
+    });
+    it("Phase 2b: deliverableKind='answer' is informational even for an imperative (no '?') prompt", async () => {
+        // The raw text is a plain imperative — the legacy regex (isQuestionLike /
+        // isMetaAnalysisPrompt) would NOT mark it informational. The model's
+        // deliverableKind='answer' must override that and route to the QUESTION
+        // directive — proving L4 consumes the model signal, not the regex.
+        const raw = "go over the auth module and tell me what it does";
+        const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "analyze", intentKind: "task", deliverableKind: "answer" }));
+        expect(result.enriched).toContain("QUESTION / explanatory");
+    });
+    it("Phase 2b: deliverableKind='code' is NOT informational even for a question-shaped prompt", async () => {
+        // The raw text reads as a question — the legacy regex would mark it
+        // informational. The model's deliverableKind='code' must override that so
+        // the STANDARD implement scaffold is used (the deliverable is file edits).
+        const raw = "why not just refactor the dropdown and wire the keyboard handlers?";
+        const result = await layer4Gsd(makeCtx({ raw, enriched: raw, taskType: "refactor", intentKind: "task", deliverableKind: "code" }));
+        expect(result.enriched).not.toContain("QUESTION / explanatory");
+    });
     it("uses ctx.gsdPhase from L1 (unified path) without calling routeTask", async () => {
         const { routeTask } = await import("../../ee/bridge.js");
         vi.mocked(routeTask).mockClear();