muonroi-cli 1.8.0 → 1.8.3

package/dist/src/pil/__tests__/llm-classify.test.js

@@ -1,197 +0,0 @@
-import { afterEach, beforeAll, describe, expect, it } from "vitest";
-import { installMockModel, textOnlyStream } from "../../agent-harness/mock-model.js";
-import { loadCatalog } from "../../models/registry.js";
-import { createLlmClassifier } from "../llm-classify.js";
-describe("createLlmClassifier (PIL Layer 1 Pass 4)", () => {
-    beforeAll(async () => {
-        await loadCatalog();
-    });
-    let cleanup = null;
-    afterEach(() => {
-        cleanup?.();
-        cleanup = null;
-    });
-    it("parses a clean two-word reply into TaskType + style", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-        cleanup = handle.uninstall;
-        // Build a stub factory — installMockModel routes everything through the mock anyway.
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("ci action github fail, fix giúp tôi");
-        expect(result).not.toBeNull();
-        expect(result?.taskType).toBe("debug");
-        expect(result?.outputStyle).toBe("concise");
-        expect(result?.confidence).toBeGreaterThan(0.5);
-    });
-    it("parses the three-word reply and marks chitchat from the intent word", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("general,concise,chat") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("cảm ơn bạn nhé");
-        expect(result?.taskType).toBe("general");
-        expect(result?.intentKind).toBe("chitchat");
-    });
-    it("treats a general QUESTION as task, not chitchat (keep-tools)", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("general,concise,task") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("bạn thử call tool setup_guide xem được không");
-        expect(result?.intentKind).toBe("task");
-    });
-    it("defaults intentKind to task when the model omits the third word (backward compatible)", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("fix the failing build");
-        expect(result?.taskType).toBe("debug");
-        expect(result?.intentKind).toBe("task");
-    });
-    it("returns null when the reply cannot be parsed", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("¯\\_(ツ)_/¯") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("hello");
-        expect(result).toBeNull();
-    });
-    it("accepts a taskType-only reply (style optional)", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("plan") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("design a sharded queue");
-        expect(result?.taskType).toBe("plan");
-        expect(result?.outputStyle).toBeNull();
-    });
-    it("ignores noisy formatting (markdown, quotes, newlines)", async () => {
-        const handle = installMockModel({
-            fixture: { stream: textOnlyStream('**"refactor, balanced"**\n\nrationale: ...') },
-        });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("tái cấu trúc auth module");
-        expect(result?.taskType).toBe("refactor");
-        expect(result?.outputStyle).toBe("balanced");
-    });
-    // Reasoning models (grok-4.3, deepseek-v4-flash) consumed the doomed 16-token
-    // budget on reasoning tokens FIRST → emitted zero text-delta → parseResponse
-    // saw "" → returned null. 5/5 live grok sessions showed `llm=fail`. Fix: give
-    // reasoning models a real output budget + force the lowest reasoning effort the
-    // provider supports, so the 2-word answer actually streams back.
-    it("gives a reasoning model a real output budget (not the doomed 16)", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "grok-4.3"); // reasoning:true
-        const result = await classify("fix the failing CI build");
-        expect(result?.taskType).toBe("debug");
-        const call = handle.calls[0];
-        expect(call.maxOutputTokens).toBeGreaterThanOrEqual(1024);
-    });
-    it("forces low reasoning effort for reasoning models that support it", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "grok-4.3"); // xai, supports_effort:true
-        await classify("fix the failing CI build");
-        const call = handle.calls[0];
-        expect(call.providerOptions?.xai?.reasoningEffort).toBe("low");
-    });
-    it("recovers the verdict from the reasoning channel when text is empty", async () => {
-        // Some reasoning models route the whole 2-word answer into reasoning parts
-        // and commit no text. The classifier must still recover it.
-        const reasoningOnly = [
-            { type: "stream-start", warnings: [] },
-            { type: "reasoning-start", id: "r1" },
-            { type: "reasoning-delta", id: "r1", delta: "debug,concise" },
-            { type: "reasoning-end", id: "r1" },
-            {
-                type: "finish",
-                finishReason: { unified: "stop", raw: undefined },
-                usage: {
-                    inputTokens: { total: 10, noCache: 10, cacheRead: undefined, cacheWrite: undefined },
-                    outputTokens: { total: 5, text: 0, reasoning: 5 },
-                },
-            },
-        ];
-        const handle = installMockModel({ fixture: { stream: reasoningOnly } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "grok-4.3");
-        const result = await classify("fix the failing CI build");
-        expect(result?.taskType).toBe("debug");
-        expect(result?.outputStyle).toBe("concise");
-    });
-    it("keeps a tiny output budget for non-reasoning models (48 — seven comma words)", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("generate,concise") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "Qwen/Qwen3-8B"); // reasoning:false
-        await classify("add a new endpoint");
-        const call = handle.calls[0];
-        expect(call.maxOutputTokens).toBe(48);
-    });
-    it("parses the sixth + seventh words as agent-first scope and reply-language", async () => {
-        const eco = installMockModel({
-            fixture: { stream: textOnlyStream("analyze,balanced,task,answer,standard,ecosystem,vietnamese") },
-        });
-        cleanup = eco.uninstall;
-        const ecoClassify = createLlmClassifier((() => eco.model), "deepseek-v4-flash");
-        const r = await ecoClassify("hệ sinh thái muonroi gồm những gì");
-        expect(r?.ecosystemScope).toBe(true);
-        expect(r?.replyLanguage).toBe("Vietnamese");
-        eco.uninstall();
-        // English + local → no nudge signals (ecosystemScope false, replyLanguage null).
-        const plain = installMockModel({
-            fixture: { stream: textOnlyStream("debug,concise,task,code,standard,local,english") },
-        });
-        cleanup = plain.uninstall;
-        const plainClassify = createLlmClassifier((() => plain.model), "deepseek-v4-flash");
-        const p = await plainClassify("fix the crash");
-        expect(p?.ecosystemScope).toBe(false);
-        expect(p?.replyLanguage).toBeNull();
-    });
-    it("parses the fourth word as the output deliverable (Phase 2b)", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise,task,code,standard") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const classify = createLlmClassifier(factory, "deepseek-v4-flash");
-        const result = await classify("fix the crash in src/auth/login.ts");
-        expect(result?.taskType).toBe("debug");
-        expect(result?.deliverableKind).toBe("code");
-    });
-    it("parses the fifth word as the model-decided work depth (agent-first tier)", async () => {
-        const heavy = installMockModel({ fixture: { stream: textOnlyStream("refactor,concise,task,code,heavy") } });
-        cleanup = heavy.uninstall;
-        const heavyClassify = createLlmClassifier((() => heavy.model), "deepseek-v4-flash");
-        expect((await heavyClassify("rework the auth system"))?.depthTier).toBe("heavy");
-        heavy.uninstall();
-        // Position-independent recovery (taskType still leads; depth appears early).
-        const reordered = installMockModel({ fixture: { stream: textOnlyStream("debug,quick,concise,task,code") } });
-        cleanup = reordered.uninstall;
-        const reorderedClassify = createLlmClassifier((() => reordered.model), "deepseek-v4-flash");
-        expect((await reorderedClassify("fix typo"))?.depthTier).toBe("quick");
-        reordered.uninstall();
-        const noDepth = installMockModel({ fixture: { stream: textOnlyStream("debug,concise,task,code") } });
-        cleanup = noDepth.uninstall;
-        const noDepthClassify = createLlmClassifier((() => noDepth.model), "deepseek-v4-flash");
-        expect((await noDepthClassify("fix the bug"))?.depthTier).toBeNull();
-    });
-    it("recovers the deliverable position-independently and defaults to null when absent", async () => {
-        const reportHandle = installMockModel({ fixture: { stream: textOnlyStream("analyze,concise,task,report") } });
-        cleanup = reportHandle.uninstall;
-        const reportClassify = createLlmClassifier((() => reportHandle.model), "deepseek-v4-flash");
-        expect((await reportClassify("list every env var the CLI reads"))?.deliverableKind).toBe("report");
-        reportHandle.uninstall();
-        // Model omits the 4th word → deliverableKind null (consumers fall back to regex).
-        const bareHandle = installMockModel({ fixture: { stream: textOnlyStream("debug,concise") } });
-        cleanup = bareHandle.uninstall;
-        const bareClassify = createLlmClassifier((() => bareHandle.model), "deepseek-v4-flash");
-        expect((await bareClassify("fix it"))?.deliverableKind).toBeNull();
-    });
-});
-//# sourceMappingURL=llm-classify.test.js.map

package/dist/src/pil/__tests__/native-capabilities-workbook.test.d.ts

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

package/dist/src/pil/__tests__/native-capabilities-workbook.test.js

@@ -1,40 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { buildNativeCapabilitiesSection, NATIVE_CAPABILITIES } from "../native-capabilities-workbook.js";
-describe("buildNativeCapabilitiesSection", () => {
-    afterEach(() => {
-        process.env.MUONROI_DISABLE_NATIVE_CAPABILITIES = undefined;
-    });
-    it("emits the manifest for agent mode (non-chitchat)", () => {
-        const out = buildNativeCapabilitiesSection({ mode: "agent", chitchat: false });
-        expect(out).toContain("NATIVE CAPABILITIES");
-        expect(out.endsWith("\n\n")).toBe(true);
-    });
-    it("names the load-bearing affordances the agent previously could not see", () => {
-        // Regression: these are the capabilities the in-CLI agent reconstructed by
-        // grepping source (session d95113d3be09). They MUST appear in the manifest.
-        for (const token of [
-            "ee_query",
-            "tool-artifact",
-            'task(agent="explore"',
-            "delegate(",
-            "self-verify",
-            "usage forensics",
-            "bash_output_get",
-            "[Discovery]",
-        ]) {
-            expect(NATIVE_CAPABILITIES).toContain(token);
-        }
-    });
-    it("is empty for chitchat turns", () => {
-        expect(buildNativeCapabilitiesSection({ mode: "agent", chitchat: true })).toBe("");
-    });
-    it("is empty for non-agent modes (plan/ask have a restricted toolset)", () => {
-        expect(buildNativeCapabilitiesSection({ mode: "plan", chitchat: false })).toBe("");
-        expect(buildNativeCapabilitiesSection({ mode: "ask", chitchat: false })).toBe("");
-    });
-    it("respects the MUONROI_DISABLE_NATIVE_CAPABILITIES escape hatch", () => {
-        process.env.MUONROI_DISABLE_NATIVE_CAPABILITIES = "1";
-        expect(buildNativeCapabilitiesSection({ mode: "agent", chitchat: false })).toBe("");
-    });
-});
-//# sourceMappingURL=native-capabilities-workbook.test.js.map

package/dist/src/pil/__tests__/ollama-classify.test.d.ts

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

package/dist/src/pil/__tests__/ollama-classify.test.js

@@ -1,68 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { ollamaClassify } from "../ollama-classify.js";
-const originalFetch = globalThis.fetch;
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-afterEach(() => {
-    globalThis.fetch = originalFetch;
-});
-function mockFetch(response, ok = true) {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-        ok,
-        json: () => Promise.resolve(response),
-    });
-}
-describe("ollamaClassify", () => {
-    it("returns taskType when Ollama responds with valid category", async () => {
-        mockFetch({ response: "debug" });
-        const result = await ollamaClassify("something is broken");
-        expect(result).toEqual({ taskType: "debug", confidence: 0.55 });
-    });
-    it('returns taskType for "refactor" response', async () => {
-        mockFetch({ response: "refactor" });
-        const result = await ollamaClassify("clean up this code");
-        expect(result).toEqual({ taskType: "refactor", confidence: 0.55 });
-    });
-    it('returns null when Ollama responds with "none"', async () => {
-        mockFetch({ response: "none" });
-        const result = await ollamaClassify("hello world");
-        expect(result).toBeNull();
-    });
-    it("returns null when Ollama responds with unrecognized text", async () => {
-        mockFetch({ response: "I think this is a question about cooking" });
-        const result = await ollamaClassify("how to make pasta");
-        expect(result).toBeNull();
-    });
-    it("returns null when fetch throws (Ollama unavailable)", async () => {
-        globalThis.fetch = vi.fn().mockRejectedValue(new Error("ECONNREFUSED"));
-        const result = await ollamaClassify("test prompt");
-        expect(result).toBeNull();
-    });
-    it("returns null when response is not ok (500)", async () => {
-        mockFetch({}, false);
-        const result = await ollamaClassify("test prompt");
-        expect(result).toBeNull();
-    });
-    it("returns null when fetch is aborted (timeout)", async () => {
-        globalThis.fetch = vi.fn().mockRejectedValue(new DOMException("Aborted", "AbortError"));
-        const result = await ollamaClassify("test prompt");
-        expect(result).toBeNull();
-    });
-    it("confidence is always 0.55 for Ollama results", async () => {
-        mockFetch({ response: "plan" });
-        const result = await ollamaClassify("design the architecture");
-        expect(result?.confidence).toBe(0.55);
-    });
-    it("handles empty response field gracefully", async () => {
-        mockFetch({ response: "" });
-        const result = await ollamaClassify("test");
-        expect(result).toBeNull();
-    });
-    it("handles missing response field gracefully", async () => {
-        mockFetch({});
-        const result = await ollamaClassify("test");
-        expect(result).toBeNull();
-    });
-});
-//# sourceMappingURL=ollama-classify.test.js.map

package/dist/src/pil/__tests__/orchestrator-integration.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * src/pil/__tests__/orchestrator-integration.test.ts
- *
- * Integration-level unit tests verifying the PIL orchestrator contract:
- * - enriched message is used when pipeline succeeds
- * - applyPilSuffix injects OUTPUT RULES suffix for coding taskTypes
- * - applyPilSuffix skips suffix when taskType is null
- * - catch fallback uses raw message (fail-open contract)
- */
-export {};

package/dist/src/pil/__tests__/orchestrator-integration.test.js

@@ -1,100 +0,0 @@
-/**
- * src/pil/__tests__/orchestrator-integration.test.ts
- *
- * Integration-level unit tests verifying the PIL orchestrator contract:
- * - enriched message is used when pipeline succeeds
- * - applyPilSuffix injects OUTPUT RULES suffix for coding taskTypes
- * - applyPilSuffix skips suffix when taskType is null
- * - catch fallback uses raw message (fail-open contract)
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Mock classifier and EE bridge before importing pipeline
-vi.mock("../../router/classifier/index.js", () => ({
-    classify: vi.fn().mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" }),
-}));
-vi.mock("../../ee/bridge.js", () => ({
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    routeTask: vi.fn().mockResolvedValue(null),
-    getWhoAmIProfile: vi.fn(() => null),
-    outputStyleFromProfile: vi.fn(() => null),
-}));
-import { applyPilSuffix, runPipeline } from "../index.js";
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe("PIL orchestrator contract", () => {
-    it("enriched message is used when pipeline succeeds", async () => {
-        const ctx = await runPipeline("refactor this function");
-        // Layer 2 personality now appends hints, so enriched starts with raw
-        expect(ctx.enriched.startsWith("refactor this function")).toBe(true);
-        expect(ctx.layers).toHaveLength(7);
-    });
-    it("applyPilSuffix appends OUTPUT RULES suffix for coding taskType (non-null)", () => {
-        const codingCtx = {
-            raw: "refactor the loop",
-            enriched: "refactor the loop",
-            taskType: "refactor",
-            domain: null,
-            confidence: 0.85,
-            outputStyle: "concise",
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const base = "You are a helpful assistant.";
-        const result = applyPilSuffix(base, codingCtx);
-        expect(result).toContain("OUTPUT RULES");
-        expect(result.startsWith(base)).toBe(true);
-    });
-    it("applyPilSuffix does NOT append suffix when taskType is null", () => {
-        const nullCtx = {
-            raw: "hello world",
-            enriched: "hello world",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const base = "You are a helpful assistant.";
-        const result = applyPilSuffix(base, nullCtx);
-        expect(result).toBe(base);
-        expect(result).not.toContain("OUTPUT RULES");
-    });
-    it("catch fallback uses raw userMessage (fail-open contract matches orchestrator .catch())", async () => {
-        // Simulate the catch block in orchestrator:
-        // const pilCtx = await runPipeline(userMessage).catch(() => ({
-        //   raw: userMessage, enriched: userMessage, taskType: null, domain: null, layers: [],
-        // }));
-        const userMessage = "some user prompt";
-        const fallback = {
-            raw: userMessage,
-            enriched: userMessage,
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        // Verify fallback structure matches orchestrator catch shape
-        expect(fallback.enriched).toBe(userMessage);
-        expect(fallback.taskType).toBeNull();
-        expect(fallback.layers).toHaveLength(0);
-        // applyPilSuffix must return base unchanged for this fallback (taskType null)
-        const base = "System prompt";
-        expect(applyPilSuffix(base, fallback)).toBe(base);
-    });
-    it("runPipeline stores result — getPilLastResult returns same reference", async () => {
-        const { getPilLastResult } = await import("../index.js");
-        const ctx = await runPipeline("check store after pipeline");
-        const stored = getPilLastResult();
-        expect(stored).toBe(ctx);
-    });
-});
-//# sourceMappingURL=orchestrator-integration.test.js.map

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

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

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

@@ -1,188 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Mock all layer dependencies before importing pipeline
-vi.mock("../../router/classifier/index.js", () => ({
-    classify: vi.fn().mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" }),
-}));
-vi.mock("../../ee/bridge.js", () => ({
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    routeTask: vi.fn().mockResolvedValue(null),
-    getWhoAmIProfile: vi.fn(() => null),
-    outputStyleFromProfile: vi.fn(() => null),
-}));
-import { classify } from "../../router/classifier/index.js";
-import { runPipeline } from "../pipeline.js";
-import { getPilLastResult } from "../store.js";
-const mockClassify = vi.mocked(classify);
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockClassify.mockReturnValue({ tier: "hot", confidence: 0.85, reason: "regex:refactor" });
-});
-describe("runPipeline()", () => {
-    it("returns PipelineContext with 7 LayerResults for normal input", async () => {
-        const ctx = await runPipeline("refactor this function");
-        expect(ctx.raw).toBe("refactor this function");
-        expect(ctx.layers).toHaveLength(7);
-    });
-    it("returns enriched that starts with raw (layers may append hints)", async () => {
-        const ctx = await runPipeline("some prompt");
-        expect(ctx.enriched.startsWith(ctx.raw)).toBe(true);
-    });
-    it("if layer2 throws, pipeline still returns a valid context (fail-open)", async () => {
-        vi.doMock("../layer2-personality.js", () => ({
-            layer2Personality: vi.fn().mockRejectedValue(new Error("layer2 failed")),
-        }));
-        const ctx = await runPipeline("some prompt");
-        expect(ctx).toBeDefined();
-        expect(ctx.raw).toBeDefined();
-    });
-    it("after runPipeline(), getPilLastResult() returns the result", async () => {
-        const ctx = await runPipeline("test prompt for store");
-        const stored = getPilLastResult();
-        expect(stored).toBe(ctx);
-    });
-    it('runPipeline("") returns valid PipelineContext with raw="" and enriched=""', async () => {
-        const ctx = await runPipeline("");
-        expect(ctx.raw).toBe("");
-        expect(ctx.enriched.startsWith(ctx.raw)).toBe(true);
-        expect(ctx.layers).toHaveLength(7);
-    });
-    it("conversational turn (taskType=null) skips layers 2-5 with delta=skipped:null-taskType", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        const ctx = await runPipeline("hello how are you");
-        expect(ctx.layers).toHaveLength(7);
-        expect(ctx.layers[1].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[2].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[3].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[4].delta).toBe("skipped:null-taskType");
-        expect(ctx.layers[5].delta).toBe("skipped:null-taskType");
-        expect(ctx.taskType).toBeNull();
-    });
-    it("coding task runs all 7 layers normally (no skip)", async () => {
-        const ctx = await runPipeline("refactor this function");
-        expect(ctx.layers).toHaveLength(7);
-        expect(ctx.taskType).toBe("refactor");
-        // layers 2-5 (which include indices 1 to 5) should NOT have skipped delta
-        for (let i = 1; i <= 5; i++) {
-            expect(ctx.layers[i].delta).not.toBe("skipped:null-taskType");
-        }
-    });
-    it("felt-experience prompt injects the session snapshot even when taskType is null", async () => {
-        // Regression: the felt-experience injection was first placed INSIDE the
-        // `taskType !== null` branch, so a "cảm nhận trong CLI" question that
-        // classifies to null (not a coding task) silently skipped it. It must run
-        // regardless of taskType.
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        const ctx = await runPipeline("bạn có bị mù context không trong session này, cảm nhận thế nào");
-        expect(ctx.taskType).toBeNull();
-        expect(ctx.layers.find((l) => l.name === "session-experience")?.applied).toBe(true);
-        expect(ctx.enriched).toContain("[session experience —");
-        expect(ctx.enriched).toMatch(/not by reading the CLI source/i);
-    });
-    it("plain evaluate-the-CLI prompt does NOT inject the session snapshot", async () => {
-        const ctx = await runPipeline("đánh giá agent bên trong cli và đề xuất cải thiện");
-        expect(ctx.layers.find((l) => l.name === "session-experience")).toBeUndefined();
-        expect(ctx.enriched).not.toContain("[session experience —");
-    });
-    it("metrics.totalMs is a non-negative number", async () => {
-        const ctx = await runPipeline("refactor this");
-        expect(ctx.metrics).not.toBeNull();
-        expect(ctx.metrics.totalMs).toBeGreaterThanOrEqual(0);
-    });
-    it("metrics.layerTimings has 7 entries (6 layers + discovery phase)", async () => {
-        const ctx = await runPipeline("refactor this");
-        // 6 standard layer timings + 1 discovery phase timing when discovery is enabled
-        expect(ctx.metrics.layerTimings.length).toBeGreaterThanOrEqual(6);
-    });
-    it("metrics.inputChars equals raw.length", async () => {
-        const ctx = await runPipeline("hello world");
-        if (ctx.metrics) {
-            expect(ctx.metrics.inputChars).toBe("hello world".length);
-        }
-        else {
-            // Pipeline timed out (200ms race) — fallback context has null metrics. Acceptable.
-            expect(ctx.raw).toBe("hello world");
-        }
-    });
-    it("metrics.enrichmentTokensAdded is a non-negative number", async () => {
-        const ctx = await runPipeline("refactor this function");
-        if (ctx.metrics) {
-            expect(ctx.metrics.enrichmentTokensAdded).toBeGreaterThanOrEqual(0);
-        }
-        else {
-            // Pipeline timed out (200ms race) — fallback context has null metrics. Acceptable.
-            expect(ctx.raw).toBe("refactor this function");
-        }
-    });
-    it("metrics.enrichmentTokensAdded is 0 for conversational turn", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0.2, reason: "low-confidence" });
-        const ctx = await runPipeline("hello how are you");
-        expect(ctx.metrics.enrichmentTokensAdded).toBe(0);
-    });
-    it("fallback/timeout path has metrics: null", async () => {
-        // The fallback object has metrics: null
-        const { resolveAfter } = await import("../timeout.js");
-        const fallback = {
-            raw: "x",
-            enriched: "x",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const result = await resolveAfter(1, fallback);
-        expect(result.metrics).toBeNull();
-    });
-    it("timeout scenario: pipeline resolving after 200ms returns fallback ctx with layers=[]", async () => {
-        vi.useFakeTimers();
-        // Import a version where we can control timing
-        // We'll mock the layer execution to be slow
-        vi.doMock("../layer1-intent.js", () => ({
-            layer1Intent: vi.fn().mockImplementation(async (ctx) => {
-                // This will never resolve in the fake timer context before we advance
-                await new Promise((resolve) => setTimeout(resolve, 5000));
-                return ctx;
-            }),
-        }));
-        // We need a fresh import of pipeline with the slow mock
-        // Since vitest module caching is complex, we test the timeout logic directly
-        // by verifying the fallback structure
-        const { resolveAfter } = await import("../timeout.js");
-        // Verify resolveAfter returns value after ms
-        const fallback = {
-            raw: "timeout-test",
-            enriched: "timeout-test",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const resultPromise = resolveAfter(200, fallback);
-        vi.advanceTimersByTime(201);
-        const result = await resultPromise;
-        expect(result).toBe(fallback);
-        expect(result.layers).toHaveLength(0);
-        expect(result.taskType).toBeNull();
-        vi.useRealTimers();
-    });
-    it("skip-path timings use canonical layerN-* names (no 'layer-' prefix)", async () => {
-        // Force classifier to abstain so taskType stays null and skip-path triggers.
-        mockClassify.mockReturnValue({ tier: "abstain", confidence: 0, reason: "regex:no-match" });
-        const { runPipeline } = await import("../pipeline.js");
-        const result = await runPipeline("@@@@@ @@@@@ @@@@@ @@@@@");
-        const timingNames = result.metrics?.layerTimings.map((t) => t.name) ?? [];
-        expect(timingNames).toContain("layer2-personality");
-        expect(timingNames).toContain("layer3-ee-injection");
-        expect(timingNames).toContain("layer4-gsd-structuring");
-        expect(timingNames).toContain("layer5-context-enrichment");
-        expect(timingNames).not.toContain("layer-personality-adaptation");
-    });
-});
-//# sourceMappingURL=pipeline.test.js.map

package/dist/src/pil/__tests__/renderer-coverage.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Build-time guard: every PIL response schema must have a UI renderer case in
- * StructuredResponseView (src/ui/app.tsx). Without this, adding a new taskType
- * + schema and forgetting to update the UI silently falls back to raw-JSON
- * dump (or the graceful "renderer missing" warning).
- */
-export {};