muonroi-cli 1.8.0 → 1.8.3

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

@@ -1,138 +0,0 @@
-/**
- * Tests for the IntentDetectionTrace returned by Layer 1.
- * Verifies that each pass marks itself correctly in the trace so the
- * pil-report command can answer "which pass actually decided the outcome".
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-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,
-    isLlmFirstClassifyEnabled: mockIsLlmFirstClassifyEnabled,
-    // Pass-3 unified reads the client-side budget; whole-module mock replaces the
-    // real export, so it must be provided or the call site throws.
-    getUnifiedPilBudgetMs: vi.fn(() => 3500),
-}));
-import { layer1Intent } from "../layer1-intent.js";
-function makeCtx(raw) {
-    return {
-        raw,
-        enriched: raw,
-        taskType: null,
-        domain: null,
-        confidence: 0,
-        outputStyle: null,
-        tokenBudget: 500,
-        metrics: null,
-        layers: [],
-    };
-}
-beforeEach(() => {
-    vi.resetAllMocks();
-    mockIsUnifiedPilEnabled.mockReturnValue(false);
-    mockClassifyViaBrain.mockResolvedValue(null);
-    mockPilContext.mockResolvedValue(null);
-});
-describe("IntentDetectionTrace", () => {
-    it("Pass 1 hit: high-confidence classifier reason maps to taskType; no legacy TASK brain call", async () => {
-        // 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("regex:refactor");
-        expect(trace.pass1TaskType).toBe("refactor");
-        expect(trace.pass1Hit).toBe(true);
-        expect(trace.pass2Hit).toBe(false);
-        expect(trace.pass25ChitchatHit).toBe(false);
-        expect(trace.pass3UnifiedAttempted).toBe(false);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        // Style brain may still fire (no explicit style cue in prompt) — that's
-        // the 800ms style call, separately tracked.
-        expect(trace.finalTaskType).toBe("refactor");
-    });
-    it("Pass 2 hit: keyword fallback picks up debug; no legacy TASK brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        const result = await layer1Intent(makeCtx("there is a bug in the login flow"));
-        const trace = result._intentTrace;
-        expect(trace.pass1Hit).toBe(false);
-        expect(trace.pass2Hit).toBe(true);
-        expect(trace.pass2Pattern).toMatch(/bug/);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        expect(trace.finalTaskType).toBe("debug");
-    });
-    it("Pass 2.5 chitchat hit: short greeting takes the hot-path", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", reason: "regex:short-message", confidence: 0.3 });
-        const result = await layer1Intent(makeCtx("hi"));
-        const trace = result._intentTrace;
-        expect(trace.pass25ChitchatHit).toBe(true);
-        expect(trace.finalTaskType).toBe("general");
-        expect(trace.styleSource).toBe("chitchat-default");
-        expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-    });
-    it("Pass 3 unified attempted + succeeded when flag is on and local signal weak", async () => {
-        mockIsUnifiedPilEnabled.mockReturnValue(true);
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        mockPilContext.mockResolvedValueOnce({
-            taskType: "plan",
-            intentKind: "task",
-            outputStyle: "balanced",
-            confidence: 0.8,
-            t0_principles: [],
-            t1_rules: [],
-            t2_patterns: [],
-            retrieval_skipped_reason: null,
-        });
-        const result = await layer1Intent(makeCtx("vague architecture question"));
-        const trace = result._intentTrace;
-        expect(trace.pass3UnifiedAttempted).toBe(true);
-        expect(trace.pass3UnifiedSucceeded).toBe(true);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-        expect(trace.styleSource).toBe("brain-unified");
-        expect(trace.finalTaskType).toBe("plan");
-    });
-    it("Pass 3 unified attempted but failed: legacy NOT attempted (cost optimization)", async () => {
-        mockIsUnifiedPilEnabled.mockReturnValue(true);
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        mockPilContext.mockResolvedValueOnce(null);
-        const result = await layer1Intent(makeCtx("vague question"));
-        const trace = result._intentTrace;
-        expect(trace.pass3UnifiedAttempted).toBe(true);
-        expect(trace.pass3UnifiedSucceeded).toBe(false);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-        expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-    });
-    it("Pass1 coding reason → styleSource=classifier-default without brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", reason: "regex:edit", confidence: 0.85 });
-        const result = await layer1Intent(makeCtx("edit this handler"));
-        const trace = result._intentTrace;
-        expect(trace.pass1Hit).toBe(true);
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-        expect(trace.styleSource).toBe("classifier-default");
-        expect(result.outputStyle).toBe("balanced");
-        expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-    });
-    it("Explicit style cue takes the regex path (styleSource=explicit-regex) and skips brain", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        const result = await layer1Intent(makeCtx("plan the architecture, chi tiết nhé"));
-        const trace = result._intentTrace;
-        expect(trace.pass2Hit).toBe(true);
-        expect(trace.styleSource).toBe("explicit-regex");
-        expect(result.outputStyle).toBe("detailed");
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-    });
-});
-//# sourceMappingURL=layer1-intent-trace.test.js.map

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

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

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

@@ -1,329 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("../../router/classifier/index.js", () => ({
-    classify: vi.fn(),
-}));
-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),
-    // Pass-3 unified reads the client-side budget; whole-module mock replaces the
-    // real export, so it must be provided or the call site throws.
-    getUnifiedPilBudgetMs: vi.fn(() => 3500),
-}));
-vi.mock("../../ee/bridge.js", () => ({
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    pilContext: vi.fn().mockResolvedValue(null),
-}));
-import { classifyViaBrain, pilContext } from "../../ee/bridge.js";
-import { classify } from "../../router/classifier/index.js";
-import { isUnifiedPilEnabled } from "../config.js";
-import { layer1Intent } from "../layer1-intent.js";
-const mockClassify = vi.mocked(classify);
-const mockClassifyViaBrain = vi.mocked(classifyViaBrain);
-const mockPilContext = vi.mocked(pilContext);
-const mockIsUnifiedPilEnabled = vi.mocked(isUnifiedPilEnabled);
-const makeCtx = (raw = "test prompt") => ({
-    raw,
-    enriched: raw,
-    taskType: null,
-    domain: null,
-    confidence: 0,
-    outputStyle: null,
-    tokenBudget: 500,
-    metrics: null,
-    layers: [],
-});
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe("layer1Intent — classifier pass", () => {
-    it("regex:refactor → refactor, confidence stored", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-        const result = await layer1Intent(makeCtx("refactor this function"));
-        expect(result.taskType).toBe("refactor");
-        expect(result.confidence).toBe(0.85);
-        expect(result.layers[0].applied).toBe(true);
-        expect(result.layers[0].delta).toContain("taskType=refactor");
-        expect(result.layers[0].delta).toContain("conf=0.85");
-    });
-    it("regex:edit → generate", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "regex:edit" });
-        const result = await layer1Intent(makeCtx("edit the file"));
-        expect(result.taskType).toBe("generate");
-    });
-    it("regex:install → analyze", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:install" });
-        const result = await layer1Intent(makeCtx("install the package"));
-        expect(result.taskType).toBe("analyze");
-        expect(result.layers[0].applied).toBe(true);
-    });
-    it("regex:run-command → analyze", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:run-command" });
-        const result = await layer1Intent(makeCtx("run bun test"));
-        expect(result.taskType).toBe("analyze");
-    });
-    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).toBeNull();
-        expect(result.domain).toBe("typescript");
-        expect(result.layers[0].applied).toBe(false);
-    });
-    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).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" });
-        // 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();
-    });
-    it("regex:search → analyze", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.8, reason: "regex:search" });
-        const result = await layer1Intent(makeCtx("search for the function"));
-        expect(result.taskType).toBe("analyze");
-    });
-});
-describe("layer1Intent — keyword fallback (classifier returns null)", () => {
-    beforeEach(() => {
-        // Simulate classifier abstain so keyword fallback activates
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-    });
-    it('keyword "bug" → debug', async () => {
-        const result = await layer1Intent(makeCtx("there is a bug in the login flow"));
-        expect(result.taskType).toBe("debug");
-        expect(result.confidence).toBe(0.65);
-        expect(result.layers[0].applied).toBe(true);
-    });
-    it('keyword "error" → debug', async () => {
-        const result = await layer1Intent(makeCtx("getting an error on line 42"));
-        expect(result.taskType).toBe("debug");
-    });
-    it('keyword "plan" → plan', async () => {
-        const result = await layer1Intent(makeCtx("plan the refactor approach"));
-        expect(result.taskType).toBe("plan");
-        expect(result.confidence).toBe(0.6);
-    });
-    it('keyword "docs" → documentation', async () => {
-        const result = await layer1Intent(makeCtx("write docs for this module"));
-        expect(result.taskType).toBe("documentation");
-        expect(result.confidence).toBe(0.6);
-    });
-    // 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 () => {
-        const result = await layer1Intent(makeCtx("hello how are you"));
-        expect(result.taskType).toBeNull();
-        expect(result.layers[0].applied).toBe(false);
-    });
-});
-describe("layer1Intent — outputStyle detection", () => {
-    it("coding task via pass1 → outputStyle defaults to balanced without brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-        const result = await layer1Intent(makeCtx("refactor this function"));
-        // Style brain is skipped when pass1 decided cheaply — default "balanced"
-        expect(result.outputStyle).toBe("balanced");
-        expect(mockClassifyViaBrain).not.toHaveBeenCalledWith(expect.stringContaining("preferred output style"), 800);
-    });
-    it("coding task via pass2 (keyword) → outputStyle defaults to balanced without brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        const result = await layer1Intent(makeCtx("there is a bug here"));
-        expect(result.outputStyle).toBe("balanced");
-        expect(mockClassifyViaBrain).not.toHaveBeenCalledWith(expect.stringContaining("preferred output style"), 800);
-    });
-    it("conversational turn (taskType=null) → outputStyle=null, no style brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        mockClassifyViaBrain.mockResolvedValue(null);
-        const result = await layer1Intent(makeCtx("hello how are you"));
-        expect(result.outputStyle).toBeNull();
-    });
-});
-describe("layer1Intent — EE brain bridge fallback (Pass 3)", () => {
-    beforeEach(() => {
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        mockClassifyViaBrain.mockResolvedValue(null);
-    });
-    it("classifyViaBrain called when classifier and keywords both miss", async () => {
-        await layer1Intent(makeCtx("some ambiguous input without keywords"));
-        expect(mockClassifyViaBrain).toHaveBeenCalled();
-        expect(mockClassifyViaBrain).toHaveBeenCalledWith(expect.stringContaining("multilingual prompt classifier"), 1500);
-    });
-    it("classifyViaBrain called with prompt containing task type and style instruction", async () => {
-        await layer1Intent(makeCtx("some ambiguous input"));
-        const [promptArg] = mockClassifyViaBrain.mock.calls[0];
-        expect(promptArg).toContain("refactor");
-        expect(promptArg).toContain("debug");
-        expect(promptArg).toContain("concise");
-        expect(promptArg).toContain("detailed");
-    });
-    it("classifyViaBrain called with 1500ms timeout for combined detection (brain-LLM realistic latency)", async () => {
-        await layer1Intent(makeCtx("some ambiguous input"));
-        expect(mockClassifyViaBrain).toHaveBeenCalledWith(expect.any(String), 1500);
-    });
-    it("brain returns 'debug' → taskType='debug', confidence=0.55", async () => {
-        mockClassifyViaBrain.mockResolvedValue("debug");
-        const result = await layer1Intent(makeCtx("some ambiguous input"));
-        expect(result.taskType).toBe("debug");
-        expect(result.confidence).toBe(0.55);
-    });
-    it("brain returns null (absent/timeout) → taskType stays null", async () => {
-        mockClassifyViaBrain.mockResolvedValue(null);
-        const result = await layer1Intent(makeCtx("some ambiguous input"));
-        expect(result.taskType).toBeNull();
-    });
-    it("brain returns 'none' → marked as chitchat (intentKind), taskType=general", async () => {
-        mockClassifyViaBrain.mockResolvedValue("none");
-        const result = await layer1Intent(makeCtx("some ambiguous input"));
-        expect(result.taskType).toBe("general");
-        expect(result.intentKind).toBe("chitchat");
-    });
-    it("brain returns garbage → taskType stays null", async () => {
-        mockClassifyViaBrain.mockResolvedValue("I cannot classify this prompt");
-        const result = await layer1Intent(makeCtx("some ambiguous input"));
-        expect(result.taskType).toBeNull();
-    });
-    it("style brain NOT called when pass1 already decided coding task (saves 800ms)", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-        await layer1Intent(makeCtx("refactor this"));
-        const styleCall = mockClassifyViaBrain.mock.calls.find((c) => String(c[0]).includes("preferred output style"));
-        expect(styleCall).toBeUndefined();
-    });
-    it("style brain NOT called when pass2 keyword fallback decided task", async () => {
-        await layer1Intent(makeCtx("there is a bug here"));
-        const styleCall = mockClassifyViaBrain.mock.calls.find((c) => String(c[0]).includes("preferred output style"));
-        expect(styleCall).toBeUndefined();
-    });
-    it("style brain IS called when task itself was ambiguous and needed brain classification", async () => {
-        // Task brain returns task only (no style token) → style brain fires next.
-        mockClassifyViaBrain
-            .mockResolvedValueOnce("debug") // task brain: no style token
-            .mockResolvedValueOnce("balanced"); // style brain
-        await layer1Intent(makeCtx("some completely ambiguous input without keywords"));
-        const styleCall = mockClassifyViaBrain.mock.calls.find((c) => String(c[0]).includes("preferred output style"));
-        expect(styleCall).toBeDefined();
-    });
-});
-describe("Layer 1 unified path", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // default: low-signal classifier so unified path becomes eligible
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-    });
-    it("calls pilContext when flag enabled AND local classify is low confidence", async () => {
-        mockIsUnifiedPilEnabled.mockReturnValue(true);
-        mockPilContext.mockResolvedValueOnce({
-            taskType: "debug",
-            intentKind: "task",
-            outputStyle: "balanced",
-            confidence: 0.85,
-            domain: "typescript",
-            gsd_phase: "execute",
-            gsd_route_source: "ee",
-            t0_principles: [{ text: "p1", score: 0.9 }],
-            t1_rules: ["r1"],
-            t2_patterns: [{ text: "x", score: 0.7 }],
-            retrieval_skipped_reason: null,
-            cache_hit: false,
-            inference_ms: 200,
-            schema_version: "1.0",
-        });
-        const result = await layer1Intent({
-            raw: "ambiguous prompt",
-            enriched: "",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        });
-        expect(result.taskType).toBe("debug");
-        expect(result.outputStyle).toBe("balanced");
-        expect(result._brainData?.t0_principles).toHaveLength(1);
-        expect(result._brainData?.t1_rules).toEqual(["r1"]);
-        expect(result.layers[0].delta).toContain("unified=ok");
-    });
-    it("skips pilContext when local classify yields high confidence (>= 0.7)", async () => {
-        mockIsUnifiedPilEnabled.mockReturnValue(true);
-        mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-        await layer1Intent({
-            raw: "refactor this function please",
-            enriched: "",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        });
-        expect(mockPilContext).not.toHaveBeenCalled();
-    });
-    it("does NOT fall back to legacy classifyViaBrain when pilContext returns null (cost optimization)", async () => {
-        // When unified PIL is enabled and its single call fails, calling the same
-        // backend a second time via classifyViaBrain wastes ~2.3s and tokens on a
-        // network that just timed out. We mark _brainData with a sentinel so L6
-        // also skips its rescue call.
-        mockIsUnifiedPilEnabled.mockReturnValue(true);
-        mockPilContext.mockResolvedValueOnce(null);
-        const result = await layer1Intent({
-            raw: "vague question",
-            enriched: "",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        });
-        expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-        expect(result.taskType).toBeNull();
-        expect(result._brainData).toEqual({
-            t0_principles: [],
-            t1_rules: [],
-            t2_patterns: [],
-            retrieval_skipped_reason: "unified-failed",
-        });
-        expect(result.layers[0].delta).toContain("unified=fail");
-    });
-});
-describe("layer1Intent — error handling", () => {
-    it("classify throws → ctx unchanged, applied=false", async () => {
-        mockClassify.mockImplementation(() => {
-            throw new Error("classify failed");
-        });
-        const ctx = makeCtx("some prompt");
-        const result = await layer1Intent(ctx);
-        expect(result.taskType).toBeNull();
-        expect(result.layers[0].applied).toBe(false);
-        expect(result.enriched).toBe(ctx.enriched);
-    });
-});
-//# sourceMappingURL=layer1-intent.test.js.map

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

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

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

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

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

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

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { modelCardToQuestion, 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: [{ path: "src/auth/", relevance: "named in prompt", exists: true }],
-    scannedAt: Date.now(),
-    cwd: "/proj",
-};
-describe("modelCardToQuestion()", () => {
-    it("maps ModelCard to CouncilQuestionData with pil-interview phase", () => {
-        const card = {
-            question: "What outcome?",
-            context: "This changes how we debug",
-            options: [
-                { label: "Error disappears", kind: "choice" },
-                { label: "Custom fix", kind: "freetext" },
-            ],
-            defaultIndex: 0,
-        };
-        const q = modelCardToQuestion(card, "q-1");
-        expect(q.phase).toBe("pil-interview");
-        expect(q.questionId).toBe("q-1");
-        expect(q.options).toBeDefined();
-        expect(q.options).toHaveLength(2);
-        expect(q.options[0].isCancel).toBeUndefined();
-        expect(q.options[0].isAdjust).toBeUndefined();
-    });
-    it("preserves isCancel and isAdjust flags from model card options", () => {
-        const card = {
-            question: "Proceed?",
-            options: [
-                { label: "Looks good, go ahead", kind: "choice" },
-                { label: "Cancel this", kind: "choice", isCancel: true },
-                { label: "Let me clarify", kind: "choice", isAdjust: true },
-            ],
-            defaultIndex: 0,
-        };
-        const q = modelCardToQuestion(card, "q-2");
-        expect(q.options[1].isCancel).toBe(true);
-        expect(q.options[2].isAdjust).toBe(true);
-    });
-});
-describe("resolveGapsNonInteractive()", () => {
-    it("fills gaps with default options from model cards", () => {
-        const cards = [
-            {
-                question: "What outcome?",
-                options: [
-                    { label: "Error resolved", kind: "choice" },
-                    { label: "Not sure", kind: "freetext" },
-                ],
-                defaultIndex: 0,
-            },
-        ];
-        const resolved = resolveGapsNonInteractive(cards, EMPTY_PROJECT, "fix auth");
-        expect(resolved.outcome).toContain("Error resolved");
-    });
-    it("falls back to raw-derived outcome when model cards are empty", () => {
-        const resolved = resolveGapsNonInteractive([], EMPTY_PROJECT, "fix the login bug");
-        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

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

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

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

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