muonroi-cli 1.8.1 → 1.8.3

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

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

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildAcceptanceCard } 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"]);
-    });
-});
-//# sourceMappingURL=layer18-acceptance.test.js.map

package/dist/src/pil/__tests__/layer2-personality.test.d.ts

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

package/dist/src/pil/__tests__/layer2-personality.test.js

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { layer2Personality } from "../layer2-personality.js";
-function makeCtx(overrides = {}) {
-    return {
-        raw: "refactor the auth module",
-        enriched: "refactor the auth module",
-        taskType: "refactor",
-        domain: null,
-        confidence: 0.9,
-        outputStyle: "concise",
-        tokenBudget: 500,
-        metrics: null,
-        layers: [{ name: "intent-detection", applied: true, delta: "taskType=refactor" }],
-        ...overrides,
-    };
-}
-describe("layer2Personality", () => {
-    test("appends personality hint for concise outputStyle", async () => {
-        const result = await layer2Personality(makeCtx({ outputStyle: "concise" }));
-        expect(result.enriched).toContain("[personality:");
-        expect(result.enriched).toContain("concise");
-        const layer = result.layers.find((l) => l.name === "personality-adaptation");
-        expect(layer).toBeDefined();
-        expect(layer.applied).toBe(true);
-    });
-    test("appends personality hint for detailed outputStyle", async () => {
-        const result = await layer2Personality(makeCtx({ outputStyle: "detailed" }));
-        expect(result.enriched).toContain("detailed");
-        const layer = result.layers.find((l) => l.name === "personality-adaptation");
-        expect(layer.applied).toBe(true);
-    });
-    test("applies balanced personality when outputStyle is balanced", async () => {
-        const result = await layer2Personality(makeCtx({ outputStyle: "balanced" }));
-        const layer = result.layers.find((l) => l.name === "personality-adaptation");
-        expect(layer.applied).toBe(true);
-    });
-    test("defaults to balanced when outputStyle is null (never skips)", async () => {
-        const result = await layer2Personality(makeCtx({ outputStyle: null }));
-        const layer = result.layers.find((l) => l.name === "personality-adaptation");
-        expect(layer).toBeDefined();
-        expect(layer.applied).toBe(true);
-        expect(result.outputStyle).toBe("balanced");
-        expect(layer.delta).toContain("source=default");
-    });
-    test("respects tokenBudget — hint stays within budget", async () => {
-        const result = await layer2Personality(makeCtx({ tokenBudget: 50 }));
-        const layer = result.layers.find((l) => l.name === "personality-adaptation");
-        if (layer?.delta) {
-            const charsMatch = layer.delta.match(/chars=(\d+)/);
-            if (charsMatch) {
-                const chars = parseInt(charsMatch[1], 10);
-                expect(chars).toBeLessThanOrEqual(50 * 4);
-            }
-        }
-    });
-});
-//# sourceMappingURL=layer2-personality.test.js.map

package/dist/src/pil/__tests__/layer2_5-ponytail.test.d.ts

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

package/dist/src/pil/__tests__/layer2_5-ponytail.test.js

@@ -1,53 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { layer2_5Ponytail } from "../layer2_5-ponytail.js";
-describe("layer2_5Ponytail", () => {
-    const originalEnv = process.env.MUONROI_PONYTAIL_DISABLE;
-    afterEach(() => {
-        if (originalEnv === undefined) {
-            delete process.env.MUONROI_PONYTAIL_DISABLE;
-        }
-        else {
-            process.env.MUONROI_PONYTAIL_DISABLE = originalEnv;
-        }
-    });
-    it("should apply ponytail instruction when enabled", async () => {
-        process.env.MUONROI_PONYTAIL_DISABLE = "0";
-        const ctx = {
-            raw: "test",
-            enriched: "test",
-            taskType: "general",
-            confidence: 1,
-            domain: null,
-            outputStyle: "balanced",
-            tokenBudget: 1000,
-            metrics: null,
-            layers: [],
-        };
-        const result = await layer2_5Ponytail(ctx);
-        expect(result.layers.length).toBe(1);
-        expect(result.layers[0].name).toBe("ponytail-mode");
-        expect(result.layers[0].applied).toBe(true);
-        expect(result.enriched).toContain("LAZY SENIOR / PONYTAIL MODE ACTIVE");
-    });
-    it("should skip ponytail instruction when disabled via env var", async () => {
-        process.env.MUONROI_PONYTAIL_DISABLE = "1";
-        const ctx = {
-            raw: "test",
-            enriched: "test",
-            taskType: "general",
-            confidence: 1,
-            domain: null,
-            outputStyle: "balanced",
-            tokenBudget: 1000,
-            metrics: null,
-            layers: [],
-        };
-        const result = await layer2_5Ponytail(ctx);
-        expect(result.layers.length).toBe(1);
-        expect(result.layers[0].name).toBe("ponytail-mode");
-        expect(result.layers[0].applied).toBe(false);
-        expect(result.layers[0].delta).toBe("skipped:disabled-by-config");
-        expect(result.enriched).toBe("test"); // Not enriched with ponytail
-    });
-});
-//# sourceMappingURL=layer2_5-ponytail.test.js.map

package/dist/src/pil/__tests__/layer3-ee-injection.test.d.ts

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