muonroi-cli 1.3.4 → 1.4.1

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

@@ -0,0 +1,38 @@
+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

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

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

@@ -0,0 +1,54 @@
+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("ClarityDimension union covers all 3 values", () => {
+        const dims = ["outcome", "scope", "constraint"];
+        expect(dims).toHaveLength(3);
+    });
+    it("DiscoveryResult has all required fields", () => {
+        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,
+        };
+        expect(result.accepted).toBe(true);
+    });
+});
+//# sourceMappingURL=discovery-types.test.js.map

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

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

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

@@ -0,0 +1,101 @@
+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" }),
+    showAcceptance: vi.fn().mockResolvedValue("accept"),
+};
+describe("runDiscovery()", () => {
+    it("auto-passes on high-confidence specific prompt", async () => {
+        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(), null);
+        expect(result.interviewed).toBe(false);
+        expect(result.accepted).toBe(true);
+    });
+    it("interviews user on vague prompt with handler", async () => {
+        const handler = {
+            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" }),
+            showAcceptance: vi.fn().mockResolvedValue("accept"),
+        };
+        const result = await runDiscovery("fix auth", {
+            taskType: "debug",
+            confidence: 0.6,
+            complexity: "low",
+            domain: "typescript",
+            outputStyle: null,
+            intentKind: "task",
+        }, process.cwd(), handler);
+        expect(result.interviewed).toBe(true);
+        expect(result.accepted).toBe(true);
+        expect(handler.askQuestion).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("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.
+            askQuestion: vi
+                .fn()
+                .mockResolvedValueOnce({ questionId: "q1", text: "done", kind: "choice" })
+                .mockResolvedValue({ questionId: "q-acc", text: "cancel", kind: "choice" }),
+            showAcceptance: vi.fn().mockResolvedValue("cancel"),
+        };
+        const result = await runDiscovery("fix auth", {
+            taskType: "debug",
+            confidence: 0.6,
+            complexity: "low",
+            domain: "typescript",
+            outputStyle: null,
+            intentKind: "task",
+        }, process.cwd(), handler);
+        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.
+        const handler = {
+            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Task completed", kind: "choice" }),
+            showAcceptance: vi.fn().mockResolvedValue("accept"),
+        };
+        const result = await runDiscovery("make the dashboard feel less cluttered", {
+            taskType: "general",
+            confidence: 0.6,
+            complexity: "low",
+            domain: null,
+            outputStyle: null,
+            intentKind: "task",
+        }, process.cwd(), handler);
+        expect(result.intentStatement).not.toBe("general: Task completed");
+        expect(result.outcome).not.toBe("Task completed");
+        // The original request must survive into the resolved outcome.
+        expect(result.outcome.toLowerCase()).toContain("dashboard");
+    });
+    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__/layer1-intent-trace.test.js

@@ -38,10 +38,12 @@ beforeEach(() => {
 });
 describe("IntentDetectionTrace", () => {
     it("Pass 1 hit: high-confidence classifier reason maps to taskType; no legacy TASK brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", reason: "tree-sitter:typescript", confidence: 0.95 });
-        const result = await layer1Intent(makeCtx("refactor handler.ts"));
+        // Phase 4 4P-1: switched from tree-sitter:typescript (now undefined) to
+        // regex:refactor — a real Pass 1 mapping that survives Phase 4.
+        mockClassify.mockReturnValue({ tier: "hot", reason: "regex:refactor", confidence: 0.95 });
+        const result = await layer1Intent(makeCtx("rename foo to bar across the module"));
         const trace = result._intentTrace;
-        expect(trace.pass1Reason).toBe("tree-sitter:typescript");
+        expect(trace.pass1Reason).toBe("regex:refactor");
         expect(trace.pass1TaskType).toBe("refactor");
         expect(trace.pass1Hit).toBe(true);
         expect(trace.pass2Hit).toBe(false);

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

@@ -57,22 +57,30 @@ describe("layer1Intent — classifier pass", () => {
         const result = await layer1Intent(makeCtx("run bun test"));
         expect(result.taskType).toBe("analyze");
     });
-    it("tree-sitter:typescript → refactor, domain=typescript", async () => {
+    it("tree-sitter:typescript → no intent signal (Phase 4 4P-1), domain still extracted", async () => {
+        // Phase 4 4P-1: tree-sitter parse reasons no longer imply refactor.
+        // They indicate code PRESENCE but carry no intent. taskType falls through
+        // to Pass 2 keyword fallback; here "const x = 1" matches nothing → null.
         mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "tree-sitter:typescript" });
         const result = await layer1Intent(makeCtx("const x = 1"));
-        expect(result.taskType).toBe("refactor");
+        expect(result.taskType).toBeNull();
         expect(result.domain).toBe("typescript");
-        expect(result.layers[0].delta).toContain("domain=typescript");
+        expect(result.layers[0].applied).toBe(false);
     });
-    it("tree-sitter:python → refactor, domain=python", async () => {
+    it("tree-sitter:python → no intent signal (Phase 4 4P-1), domain still extracted", async () => {
         mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "tree-sitter:python" });
         const result = await layer1Intent(makeCtx("def foo(): pass"));
-        expect(result.taskType).toBe("refactor");
+        expect(result.taskType).toBeNull();
         expect(result.domain).toBe("python");
+        expect(result.layers[0].applied).toBe(false);
     });
     it("low-confidence → null taskType, applied=false", async () => {
         mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.3, reason: "low-confidence" });
-        const result = await layer1Intent(makeCtx("hello there"));
+        // Use a non-social low-signal phrase: a greeting like "hello there" now
+        // correctly resolves to chitchat via the Pass 2.6 social-pleasantry gate,
+        // so it would no longer be null. This asserts the low-confidence→null path
+        // for genuinely-ambiguous (non-pleasantry) input.
+        const result = await layer1Intent(makeCtx("lorem ipsum dolor sit"));
         expect(result.taskType).toBeNull();
         expect(result.layers[0].applied).toBe(false);
         expect(result.layers[0].delta).toBeNull();
@@ -108,8 +116,18 @@ describe("layer1Intent — keyword fallback (classifier returns null)", () => {
         expect(result.taskType).toBe("documentation");
         expect(result.confidence).toBe(0.6);
     });
-    it('keyword "test" → analyze', async () => {
+    // Phase 5 BUG-E — "write tests for X" is a test-generation task, not analyze.
+    // Pass 0 pins it to `generate` deterministically before the Pass 2 keyword
+    // fallback (which used to map any test-keyword to analyze).
+    it('keyword "write tests" → generate (Pass 0 test-generation pin)', async () => {
         const result = await layer1Intent(makeCtx("write tests for the auth module"));
+        expect(result.taskType).toBe("generate");
+    });
+    // The bare "test" / "kiểm thử" keyword without a write/add verb still falls
+    // through Pass 0 (verb guard) — Pass 2 keyword fallback can then label it
+    // analyze when the request is about REVIEWING the test surface.
+    it('keyword "review tests" (no write verb) → analyze via Pass 2 keyword', async () => {
+        const result = await layer1Intent(makeCtx("review the tests for the auth module"));
         expect(result.taskType).toBe("analyze");
     });
     it("no keyword match → null (still conversational)", async () => {

package/dist/src/pil/__tests__/layer15-context-scan.test.d.ts

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

package/dist/src/pil/__tests__/layer15-context-scan.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from "vitest";
+vi.mock("../../ee/bridge.js", () => ({
+    searchByText: vi.fn().mockResolvedValue([]),
+}));
+import { detectFramework, detectLanguage, detectPackageManager, findRelevantModules, scanProjectContext, } from "../layer15-context-scan.js";
+describe("detectLanguage()", () => {
+    it("detects typescript from tsconfig.json", () => {
+        const exists = (p) => p.endsWith("tsconfig.json");
+        expect(detectLanguage("/proj", exists)).toBe("typescript");
+    });
+    it("detects python from pyproject.toml", () => {
+        const exists = (p) => p.endsWith("pyproject.toml") || p.endsWith("requirements.txt");
+        expect(detectLanguage("/proj", exists)).toBe("python");
+    });
+    it("returns null when no signal", () => {
+        expect(detectLanguage("/proj", () => false)).toBeNull();
+    });
+});
+describe("detectFramework()", () => {
+    it("detects next.js from next.config.js", () => {
+        const exists = (p) => p.includes("next.config");
+        expect(detectFramework("/proj", exists, {})).toBe("next");
+    });
+    it("detects express from deps", () => {
+        expect(detectFramework("/proj", () => false, { express: "4.0.0" })).toBe("express");
+    });
+    it("detects angular from angular.json", () => {
+        const exists = (p) => p.endsWith("angular.json");
+        expect(detectFramework("/proj", exists, {})).toBe("angular");
+    });
+});
+describe("detectPackageManager()", () => {
+    it("detects bun from bun.lockb", () => {
+        const exists = (p) => p.endsWith("bun.lockb") || p.endsWith("bun.lock");
+        expect(detectPackageManager("/proj", exists)).toBe("bun");
+    });
+    it("detects npm from package-lock.json", () => {
+        const exists = (p) => p.endsWith("package-lock.json");
+        expect(detectPackageManager("/proj", exists)).toBe("npm");
+    });
+});
+describe("findRelevantModules()", () => {
+    it("matches keyword against bounded context names", () => {
+        const bcs = [
+            { path: "src/auth/", name: "auth", entryFiles: [], exportedSymbols: [] },
+            { path: "src/billing/", name: "billing", entryFiles: [], exportedSymbols: [] },
+        ];
+        const result = findRelevantModules("fix auth bug", bcs);
+        expect(result).toHaveLength(1);
+        expect(result[0].path).toBe("src/auth/");
+    });
+    it("returns empty for no keyword matches", () => {
+        const bcs = [{ path: "src/auth/", name: "auth", entryFiles: [], exportedSymbols: [] }];
+        expect(findRelevantModules("refactor code", bcs)).toHaveLength(0);
+    });
+});
+describe("scanProjectContext()", () => {
+    it("returns a ProjectContext with cwd set", async () => {
+        const ctx = await scanProjectContext("hello world", "/proj");
+        expect(ctx.cwd).toBe("/proj");
+        expect(ctx.scannedAt).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=layer15-context-scan.test.js.map

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

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

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

@@ -0,0 +1,153 @@
+import { describe, expect, it } from "vitest";
+import { buildInterviewQuestion, detectClarityGaps, resolveGapsNonInteractive } from "../layer16-clarity.js";
+const EMPTY_PROJECT = {
+    language: "typescript",
+    framework: null,
+    packageManager: null,
+    domain: null,
+    boundedContexts: [
+        { path: "src/auth/", name: "auth", entryFiles: ["src/auth/index.ts"], exportedSymbols: ["login", "logout"] },
+        { path: "src/billing/", name: "billing", entryFiles: [], exportedSymbols: [] },
+    ],
+    eePatterns: [],
+    relevantModules: [],
+    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 = {
+            dimension: "outcome",
+            description: "no outcome",
+            suggestedQuestion: "What outcome?",
+            options: ["test passes", "no error"],
+            defaultIndex: 0,
+        };
+        const q = buildInterviewQuestion(gap, "q-1");
+        expect(q.phase).toBe("pil-interview");
+        expect(q.questionId).toBe("q-1");
+        expect(q.options).toBeDefined();
+        expect(q.options.some((o) => o.kind === "freetext")).toBe(true);
+    });
+});
+describe("resolveGapsNonInteractive()", () => {
+    it("fills gaps with best-effort from project context", () => {
+        const gaps = detectClarityGaps("fix auth", "debug", 0.7, EMPTY_PROJECT);
+        const resolved = resolveGapsNonInteractive(gaps, EMPTY_PROJECT, "fix auth");
+        expect(resolved.outcome).toBeTruthy();
+        expect(resolved.scope.length).toBeGreaterThan(0);
+    });
+});
+//# sourceMappingURL=layer16-clarity.test.js.map

package/dist/src/pil/__tests__/layer17-feasibility.test.d.ts

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

package/dist/src/pil/__tests__/layer17-feasibility.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it, vi } from "vitest";
+vi.mock("../../ee/bridge.js", () => ({
+    searchByText: vi.fn().mockResolvedValue([]),
+}));
+import { checkFeasibility } from "../layer17-feasibility.js";
+const PROJECT = {
+    language: "typescript",
+    framework: null,
+    packageManager: null,
+    domain: null,
+    boundedContexts: [{ path: "src/auth/", name: "auth", entryFiles: ["src/auth/index.ts"], exportedSymbols: [] }],
+    eePatterns: [],
+    relevantModules: [],
+    scannedAt: Date.now(),
+    cwd: "/proj",
+};
+describe("checkFeasibility()", () => {
+    it("returns no warnings when scope files exist", async () => {
+        const intent = { outcome: "done", scope: ["src/auth/"], constraints: [], gaps: [] };
+        const result = await checkFeasibility(intent, PROJECT, () => true);
+        expect(result.viable).toBe(true);
+        expect(result.warnings).toHaveLength(0);
+    });
+    it("returns warning when scope file does not exist", async () => {
+        const intent = { outcome: "done", scope: ["src/billing/pay.ts"], constraints: [], gaps: [] };
+        const result = await checkFeasibility(intent, PROJECT, () => false);
+        expect(result.warnings.length).toBeGreaterThan(0);
+        expect(result.warnings[0]).toContain("src/billing/pay.ts");
+    });
+    it("still returns viable=true even with warnings", async () => {
+        const intent = { outcome: "done", scope: ["missing.ts"], constraints: [], gaps: [] };
+        const result = await checkFeasibility(intent, PROJECT, () => false);
+        expect(result.viable).toBe(true);
+    });
+});
+//# sourceMappingURL=layer17-feasibility.test.js.map

package/dist/src/pil/__tests__/layer18-acceptance.test.d.ts

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

package/dist/src/pil/__tests__/layer18-acceptance.test.js

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+import { buildAcceptanceCard, buildAcceptanceQuestion } from "../layer18-acceptance.js";
+describe("buildAcceptanceCard()", () => {
+    it("builds card with intent, outcome, scope, and warnings", () => {
+        const intent = { outcome: "error gone", scope: ["src/auth/jwt.ts"], constraints: [], gaps: [] };
+        const feasibility = {
+            viable: true,
+            warnings: ["oauth.ts also handles tokens"],
+            adjustedScope: ["src/auth/jwt.ts"],
+        };
+        const card = buildAcceptanceCard("Fix JWT validation returning 401", intent, feasibility);
+        expect(card.intentStatement).toBe("Fix JWT validation returning 401");
+        expect(card.outcome).toBe("error gone");
+        expect(card.scope).toEqual(["src/auth/jwt.ts"]);
+        expect(card.warnings).toEqual(["oauth.ts also handles tokens"]);
+    });
+});
+describe("buildAcceptanceQuestion()", () => {
+    it("builds a CouncilQuestionData with pil-acceptance phase", () => {
+        const card = { intentStatement: "Fix auth", outcome: "done", scope: ["src/auth/"], warnings: [] };
+        const q = buildAcceptanceQuestion(card, "acc-1");
+        expect(q.phase).toBe("pil-acceptance");
+        expect(q.questionId).toBe("acc-1");
+        expect(q.options).toHaveLength(3);
+        expect(q.options[0].label).toBe("Accept");
+        expect(q.options[1].label).toBe("Adjust");
+        expect(q.options[2].label).toBe("Cancel");
+        expect(q.defaultIndex).toBe(0);
+    });
+    it("includes warnings in context when present", () => {
+        const card = { intentStatement: "Fix auth", outcome: "done", scope: ["src/auth/"], warnings: ["risk: oauth.ts"] };
+        const q = buildAcceptanceQuestion(card, "acc-2");
+        expect(q.context).toContain("risk: oauth.ts");
+    });
+    // Default flips to "Adjust" only for BLOCKING warnings (e.g. infeasibility).
+    it("defaults to Adjust (index 1) when warning is blocking", () => {
+        const card = {
+            intentStatement: "Fix auth",
+            outcome: "done",
+            scope: ["src/"],
+            warnings: ["infeasible: file does not exist"],
+        };
+        const q = buildAcceptanceQuestion(card, "acc-3");
+        expect(q.defaultIndex).toBe(1);
+    });
+    it("defaults to Accept (index 0) when no warnings", () => {
+        const card = { intentStatement: "Fix auth", outcome: "done", scope: ["src/"], warnings: [] };
+        const q = buildAcceptanceQuestion(card, "acc-4");
+        expect(q.defaultIndex).toBe(0);
+    });
+    // Fix #7 — informational mismatch warning should NOT flip default to Adjust.
+    // Evidence: session 1f29e238 ("Can you fix it?" follow-up) — the intent
+    // mismatch detector emitted "Detected debug/bug-fix signals..." which is
+    // informational; forcing Adjust looped PIL through another interview round.
+    it("defaults to Accept when only warning is intent-mismatch (informational)", () => {
+        const card = {
+            intentStatement: "debug: Complete: Can you fix it?",
+            outcome: "done",
+            scope: ["src/"],
+            warnings: ['Detected debug/bug-fix signals in your prompt ("fail") but intent reframed as "..."'],
+        };
+        const q = buildAcceptanceQuestion(card, "acc-5");
+        expect(q.defaultIndex).toBe(0);
+    });
+    it("defaults to Adjust when mix of informational + blocking warnings", () => {
+        const card = {
+            intentStatement: "Fix auth",
+            outcome: "done",
+            scope: ["src/"],
+            warnings: ["Detected debug signals — Verify before accepting", "infeasible: file does not exist"],
+        };
+        const q = buildAcceptanceQuestion(card, "acc-6");
+        expect(q.defaultIndex).toBe(1);
+    });
+});
+describe("buildAcceptanceCard() intent-mismatch detection — PIL-L6", () => {
+    const baseFeas = { viable: true, warnings: [], adjustedScope: [] };
+    it("flags warning when raw has debug signals but intent is non-debug", () => {
+        const intent = { outcome: "Feature implemented", scope: ["project"], constraints: [], gaps: [] };
+        const card = buildAcceptanceCard("generate: Feature implemented and working", intent, baseFeas, "ci action fail dùng gh check và fix cho t");
+        expect(card.warnings.length).toBeGreaterThan(0);
+        expect(card.warnings[0]).toMatch(/debug.*signals|Verify before accepting/i);
+    });
+    it("no mismatch when intent statement matches debug signal", () => {
+        const intent = { outcome: "CI green", scope: ["project"], constraints: [], gaps: [] };
+        const card = buildAcceptanceCard("debug: CI pipeline green", intent, baseFeas, "fix the ci fail");
+        expect(card.warnings).toEqual([]);
+    });
+    it("no warning when raw has no debug signals", () => {
+        const intent = { outcome: "Feature implemented", scope: ["project"], constraints: [], gaps: [] };
+        const card = buildAcceptanceCard("generate: Feature implemented and working", intent, baseFeas, "add a new button to the dashboard");
+        expect(card.warnings).toEqual([]);
+    });
+});
+//# sourceMappingURL=layer18-acceptance.test.js.map