muonroi-cli 1.8.1 → 1.8.4

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

@@ -1,275 +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 { classifySubSessionAction, 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();
-    });
-});
-describe("classifySubSessionAction", () => {
-    let cleanup = null;
-    afterEach(() => {
-        cleanup?.();
-        cleanup = null;
-    });
-    it("correctly parses SPAWN_SUB_SESSION from model response", async () => {
-        const handle = installMockModel({
-            fixture: { stream: textOnlyStream("SPAWN_SUB_SESSION,0.98,Requires writing a test suite") },
-        });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "fix all compile errors");
-        expect(result).not.toBeNull();
-        expect(result?.action).toBe("SPAWN_SUB_SESSION");
-        expect(result?.confidence).toBe(0.98);
-        expect(result?.reason).toBe("Requires writing a test suite");
-    });
-    it("correctly parses DIRECT_ANSWER from model response", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("DIRECT_ANSWER,0.95,Simple query") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "explain database index");
-        expect(result?.action).toBe("DIRECT_ANSWER");
-        expect(result?.confidence).toBe(0.95);
-    });
-    it("correctly routes greetings, thanks, or simple math via heuristic without calling LLM", async () => {
-        const factory = (() => {
-            throw new Error("Should not be called because of heuristic short-circuit");
-        });
-        const resultMath = await classifySubSessionAction(factory, "deepseek-v4-flash", "2+2");
-        expect(resultMath?.action).toBe("DIRECT_ANSWER");
-        expect(resultMath?.confidence).toBe(0.99);
-        expect(resultMath?.reason).toContain("heuristic (simple math)");
-        const resultGreeting = await classifySubSessionAction(factory, "deepseek-v4-flash", "hello");
-        expect(resultGreeting?.action).toBe("DIRECT_ANSWER");
-        expect(resultGreeting?.confidence).toBe(0.99);
-        expect(resultGreeting?.reason).toContain("heuristic (greeting)");
-        const resultThanks = await classifySubSessionAction(factory, "deepseek-v4-flash", "thank you");
-        expect(resultThanks?.action).toBe("DIRECT_ANSWER");
-        expect(resultThanks?.confidence).toBe(0.99);
-        expect(resultThanks?.reason).toContain("heuristic (thanks)");
-    });
-    it("does not route greetings/thanks via heuristic if they contain other text (fuzzy bypass prevention)", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("SPAWN_SUB_SESSION,0.95,Delete file task") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "hello, delete file X");
-        expect(result?.action).toBe("SPAWN_SUB_SESSION");
-    });
-    it("bypasses heuristic when MUONROI_DISABLE_HEURISTIC_ROUTING is set to 1", async () => {
-        process.env.MUONROI_DISABLE_HEURISTIC_ROUTING = "1";
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("SPAWN_SUB_SESSION,0.95,Forced class") } });
-        cleanup = handle.uninstall;
-        try {
-            const factory = (() => handle.model);
-            const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "hello");
-            expect(result?.action).toBe("SPAWN_SUB_SESSION");
-        }
-        finally {
-            delete process.env.MUONROI_DISABLE_HEURISTIC_ROUTING;
-        }
-    });
-    it("correctly parses ROTATE_SESSION from model response", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("ROTATE_SESSION,0.90,New topic") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "switch topic");
-        expect(result?.action).toBe("ROTATE_SESSION");
-    });
-    it("returns null when the reply cannot be parsed", async () => {
-        const handle = installMockModel({ fixture: { stream: textOnlyStream("bad response") } });
-        cleanup = handle.uninstall;
-        const factory = (() => handle.model);
-        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "test");
-        expect(result).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 {};