muonroi-cli 1.8.1 → 1.8.4

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

@@ -1,202 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { OutputStyleSchema, PilContextResponseSchema, PipelineContextSchema, PipelineMetricsSchema, TaskTypeSchema, } from "../schema.js";
-describe("PipelineContextSchema", () => {
-    const validCtx = {
-        raw: "test",
-        enriched: "test",
-        taskType: "refactor",
-        domain: null,
-        confidence: 0.85,
-        outputStyle: "concise",
-        tokenBudget: 500,
-        metrics: null,
-        layers: [{ name: "intent-detection", applied: true, delta: "taskType=refactor" }],
-    };
-    it("accepts valid PipelineContext", () => {
-        const result = PipelineContextSchema.safeParse(validCtx);
-        expect(result.success).toBe(true);
-    });
-    it("accepts null taskType and outputStyle", () => {
-        const result = PipelineContextSchema.safeParse({
-            ...validCtx,
-            taskType: null,
-            outputStyle: null,
-        });
-        expect(result.success).toBe(true);
-    });
-    it("rejects confidence > 1", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, confidence: 1.5 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects confidence < 0", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, confidence: -0.1 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid taskType", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, taskType: "invalid" });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid outputStyle", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, outputStyle: "verbose" });
-        expect(result.success).toBe(false);
-    });
-    it("rejects tokenBudget <= 0", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, tokenBudget: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("safeParse never throws", () => {
-        expect(() => PipelineContextSchema.safeParse(null)).not.toThrow();
-        expect(() => PipelineContextSchema.safeParse(undefined)).not.toThrow();
-        expect(() => PipelineContextSchema.safeParse(42)).not.toThrow();
-        expect(() => PipelineContextSchema.safeParse("string")).not.toThrow();
-    });
-    it("accepts valid metrics object", () => {
-        const result = PipelineContextSchema.safeParse({
-            ...validCtx,
-            metrics: {
-                totalMs: 5,
-                layerTimings: [{ name: "l1", ms: 2 }],
-                inputChars: 10,
-                outputChars: 10,
-                suffixInstructionTokens: 20,
-                enrichmentTokensAdded: 0,
-            },
-        });
-        expect(result.success).toBe(true);
-    });
-    it("accepts null metrics", () => {
-        const result = PipelineContextSchema.safeParse({ ...validCtx, metrics: null });
-        expect(result.success).toBe(true);
-    });
-});
-describe("PipelineMetricsSchema", () => {
-    it("accepts valid metrics", () => {
-        const result = PipelineMetricsSchema.safeParse({
-            totalMs: 10,
-            layerTimings: [],
-            inputChars: 5,
-            outputChars: 5,
-            suffixInstructionTokens: 0,
-            enrichmentTokensAdded: 0,
-        });
-        expect(result.success).toBe(true);
-    });
-    it("rejects negative totalMs", () => {
-        const result = PipelineMetricsSchema.safeParse({
-            totalMs: -1,
-            layerTimings: [],
-            inputChars: 0,
-            outputChars: 0,
-            suffixInstructionTokens: 0,
-            enrichmentTokensAdded: 0,
-        });
-        expect(result.success).toBe(false);
-    });
-});
-describe("TaskTypeSchema", () => {
-    it.each(["refactor", "debug", "plan", "analyze", "documentation", "generate"])("accepts %s", (t) => {
-        expect(TaskTypeSchema.safeParse(t).success).toBe(true);
-    });
-    it("rejects unknown type", () => {
-        expect(TaskTypeSchema.safeParse("unknown").success).toBe(false);
-    });
-});
-describe("OutputStyleSchema", () => {
-    it.each(["concise", "detailed", "balanced"])("accepts %s", (s) => {
-        expect(OutputStyleSchema.safeParse(s).success).toBe(true);
-    });
-    it("rejects unknown style", () => {
-        expect(OutputStyleSchema.safeParse("verbose").success).toBe(false);
-    });
-});
-describe("PilContextResponseSchema", () => {
-    const validResponse = {
-        taskType: "debug",
-        intentKind: "task",
-        outputStyle: "balanced",
-        confidence: 0.85,
-        domain: "typescript",
-        gsd_phase: "execute",
-        gsd_route_source: "ee",
-        t0_principles: [{ text: "principle one", score: 0.9 }],
-        t1_rules: ["always run tests after edit"],
-        t2_patterns: [{ text: "pattern one", score: 0.7 }],
-        retrieval_skipped_reason: null,
-        cache_hit: false,
-        inference_ms: 1234,
-        schema_version: "1.0",
-    };
-    it("accepts a complete valid response", () => {
-        const result = PilContextResponseSchema.safeParse(validResponse);
-        expect(result.success).toBe(true);
-    });
-    it("accepts nullable taskType / intentKind / domain / gsd_phase", () => {
-        const r = PilContextResponseSchema.safeParse({
-            ...validResponse,
-            taskType: null,
-            intentKind: null,
-            domain: null,
-            gsd_phase: null,
-        });
-        expect(r.success).toBe(true);
-    });
-    it("rejects when outputStyle is missing (must always be provided)", () => {
-        const { outputStyle, ...rest } = validResponse;
-        void outputStyle;
-        const r = PilContextResponseSchema.safeParse(rest);
-        expect(r.success).toBe(false);
-    });
-    it("rejects when confidence is out of [0,1]", () => {
-        const r = PilContextResponseSchema.safeParse({ ...validResponse, confidence: 1.5 });
-        expect(r.success).toBe(false);
-    });
-    it("rejects when schema_version is missing", () => {
-        const { schema_version, ...rest } = validResponse;
-        void schema_version;
-        const r = PilContextResponseSchema.safeParse(rest);
-        expect(r.success).toBe(false);
-    });
-    it("ignores unknown fields (forward-compat for v1.1)", () => {
-        const r = PilContextResponseSchema.safeParse({ ...validResponse, whoami_directives: ["x"] });
-        expect(r.success).toBe(true);
-    });
-});
-describe("PipelineContext _brainData field", () => {
-    it("PipelineContextSchema accepts optional _brainData", () => {
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-            _brainData: {
-                t0_principles: [{ text: "a", score: 0.8 }],
-                t1_rules: ["b"],
-                t2_patterns: [],
-                retrieval_skipped_reason: null,
-            },
-        };
-        const r = PipelineContextSchema.safeParse(ctx);
-        expect(r.success).toBe(true);
-    });
-    it("PipelineContextSchema accepts missing _brainData (legacy path)", () => {
-        const ctx = {
-            raw: "x",
-            enriched: "x",
-            taskType: null,
-            domain: null,
-            confidence: 0,
-            outputStyle: null,
-            tokenBudget: 500,
-            metrics: null,
-            layers: [],
-        };
-        const r = PipelineContextSchema.safeParse(ctx);
-        expect(r.success).toBe(true);
-    });
-});
-//# sourceMappingURL=schema.test.js.map

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

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

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

@@ -1,119 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { scoreComplexity } from "../layer1-intent.js";
-// Helper: build a string of exactly `n` characters (plain ASCII 'a').
-const str = (n) => "a".repeat(n);
-describe("scoreComplexity — signal isolation", () => {
-    it("1. empty text → score 0, complexity low", () => {
-        const out = scoreComplexity({ rawText: "", taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(0);
-        expect(out.complexity).toBe("low");
-    });
-    it("2. 100-char text → score 1 (length +1), complexity low", () => {
-        const out = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(1);
-        expect(out.complexity).toBe("low");
-    });
-    it("3. 250-char text → score 2 (length +2), complexity low", () => {
-        const out = scoreComplexity({ rawText: str(250), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(2);
-        expect(out.complexity).toBe("low");
-    });
-    it("4. 800-char text → score 3 (length +3), complexity medium", () => {
-        const out = scoreComplexity({ rawText: str(800), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(3);
-        expect(out.complexity).toBe("medium");
-    });
-    it("5. text with 2 file references + 60-char length → score 2, complexity low", () => {
-        // 60 chars ensures length +1; 2 file refs → +1; total = 2 → low
-        const base = "Update foo.ts and bar.py";
-        const padded = base + " ".repeat(60 - base.length);
-        const out = scoreComplexity({ rawText: padded, taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(2);
-        expect(out.complexity).toBe("low");
-    });
-    it("6. 'fix typo in readme' → keyword -3, score negative, complexity low", () => {
-        const out = scoreComplexity({
-            rawText: "fix typo in readme",
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(out.score).toBeLessThan(0);
-        expect(out.complexity).toBe("low");
-    });
-    it("7. high-complexity keywords → score ≥ 3 (medium/high), never low", () => {
-        // 'Architecture migration plan for multi-tenant SaaS' is 49 chars → length +0,
-        // FORCE_HIGH_RE matches → +3; score = 3 → medium per the bucketing table.
-        // A longer variant (200+ chars) pushes it to high.
-        const shortOut = scoreComplexity({
-            rawText: "Architecture migration plan for multi-tenant SaaS",
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(shortOut.score).toBeGreaterThanOrEqual(3);
-        expect(shortOut.complexity).not.toBe("low");
-        // 250-char version: length +2 + FORCE_HIGH_RE +3 = 5 → medium; still not low.
-        const medOut = scoreComplexity({
-            rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(200)}`,
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(medOut.score).toBeGreaterThanOrEqual(5);
-        expect(medOut.complexity).not.toBe("low");
-        // 600-char version: length +3 + FORCE_HIGH_RE +3 = 6 → high.
-        const highOut = scoreComplexity({
-            rawText: `Architecture migration plan for multi-tenant SaaS ${"a".repeat(560)}`,
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(highOut.score).toBeGreaterThanOrEqual(6);
-        expect(highOut.complexity).toBe("high");
-    });
-    it("8. hasMaxSprintsOne=true with short text → score -2, low", () => {
-        const out = scoreComplexity({ rawText: str(20), taskType: null, t0HitCount: 0, hasMaxSprintsOne: true });
-        // length=0, hasMaxSprintsOne=-2 → -2
-        expect(out.score).toBe(-2);
-        expect(out.complexity).toBe("low");
-    });
-    it("9. t0HitCount=5 reduces score by 1", () => {
-        const baseline = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        const withHits = scoreComplexity({ rawText: str(100), taskType: null, t0HitCount: 5, hasMaxSprintsOne: false });
-        expect(withHits.score).toBe(baseline.score - 1);
-    });
-    it("10. taskType='debug' adds +1 (medium boundary case)", () => {
-        // 250 chars → length +2, debug +1 → 3 → medium
-        const out = scoreComplexity({ rawText: str(250), taskType: "debug", t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.score).toBe(3);
-        expect(out.complexity).toBe("medium");
-    });
-});
-describe("scoreComplexity — integration", () => {
-    it("11a. 'fix typo in README' → low", () => {
-        const out = scoreComplexity({
-            rawText: "fix typo in README.md",
-            taskType: null,
-            t0HitCount: 0,
-            hasMaxSprintsOne: false,
-        });
-        expect(out.complexity).toBe("low");
-    });
-    it("11b. 'refactor the auth subsystem' (60 chars + refactor keyword) → high", () => {
-        const text = "refactor the auth subsystem".padEnd(60, " ");
-        const out = scoreComplexity({ rawText: text, taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        // length=60 → +1, refactor kw → +3 → 4 → medium, but let's check actual
-        // 'refactor' matches FORCE_HIGH_RE (+3) + length 60 chars (+1) = 4 → medium
-        // The plan says "high" but 4 is medium with the current table.
-        // Per the plan: "60 chars + refactor kw → high" — reconcile: 60 chars = +1, refactor = +3 → 4 = medium.
-        // The plan description appears to be approximate; trust the heuristic table.
-        expect(out.score).toBeGreaterThanOrEqual(3);
-        expect(["medium", "high"]).toContain(out.complexity);
-    });
-    it("11c. 'build a counter' (short, no keywords) → low", () => {
-        const out = scoreComplexity({ rawText: "build a counter", taskType: null, t0HitCount: 0, hasMaxSprintsOne: false });
-        expect(out.complexity).toBe("low");
-    });
-});
-//# sourceMappingURL=scoreComplexity.test.js.map

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

@@ -1,8 +0,0 @@
-/**
- * Unit tests for scoreSufficiency — the context-sufficiency gate that decides
- * whether the /ideal dispatcher MUST force the Council path (and AskCard
- * discovery) regardless of complexity. Vague briefs like "todo app" are
- * exactly the case where an Agile team would stop and discover, not
- * scaffold-and-pray.
- */
-export {};

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

@@ -1,89 +0,0 @@
-/**
- * Unit tests for scoreSufficiency — the context-sufficiency gate that decides
- * whether the /ideal dispatcher MUST force the Council path (and AskCard
- * discovery) regardless of complexity. Vague briefs like "todo app" are
- * exactly the case where an Agile team would stop and discover, not
- * scaffold-and-pray.
- */
-import { describe, expect, it } from "vitest";
-import { scoreSufficiency } from "../layer1-intent.js";
-describe("scoreSufficiency — vague briefs MUST go through Council", () => {
-    it("'todo app' → not sufficient, missing scope + intent", () => {
-        const out = scoreSufficiency({ rawText: "todo app" });
-        expect(out.sufficient).toBe(false);
-        expect(out.missing).toContain("scope");
-        expect(out.missing).toContain("intent");
-    });
-    it("'crm system' → not sufficient, scope missing", () => {
-        const out = scoreSufficiency({ rawText: "crm system" });
-        expect(out.sufficient).toBe(false);
-        expect(out.missing).toContain("scope");
-    });
-    it("'build a chat platform' → not sufficient, scope missing", () => {
-        const out = scoreSufficiency({ rawText: "build a chat platform" });
-        expect(out.sufficient).toBe(false);
-        expect(out.missing).toContain("scope");
-    });
-    it("'dashboard for users' → not sufficient, scope missing", () => {
-        const out = scoreSufficiency({ rawText: "dashboard for users" });
-        expect(out.sufficient).toBe(false);
-        expect(out.missing).toContain("scope");
-    });
-    it("empty string → not sufficient, all three categories missing", () => {
-        const out = scoreSufficiency({ rawText: "" });
-        expect(out.sufficient).toBe(false);
-        expect(out.missing).toEqual(expect.arrayContaining(["scope", "target", "intent"]));
-    });
-    it("single short word 'todo' → not sufficient, intent + target missing", () => {
-        const out = scoreSufficiency({ rawText: "todo" });
-        expect(out.sufficient).toBe(false);
-        expect(out.missing).toContain("intent");
-        expect(out.missing).toContain("target");
-    });
-});
-describe("scoreSufficiency — context-complete prompts CAN skip Council", () => {
-    it("'fix typo in src/foo.ts:42' → sufficient (file ref + concrete verb)", () => {
-        const out = scoreSufficiency({ rawText: "fix typo in src/foo.ts:42" });
-        expect(out.sufficient).toBe(true);
-        expect(out.missing).toEqual([]);
-    });
-    it("'rename FooService to BarService' → sufficient (concrete verb)", () => {
-        const out = scoreSufficiency({ rawText: "rename FooService to BarService" });
-        expect(out.sufficient).toBe(true);
-    });
-    it("'add validation to UserController.cs' → sufficient (file ref + verb)", () => {
-        const out = scoreSufficiency({ rawText: "add validation to UserController.cs" });
-        expect(out.sufficient).toBe(true);
-    });
-    it("'delete unused import in src/utils.ts' → sufficient", () => {
-        const out = scoreSufficiency({ rawText: "delete unused import in src/utils.ts" });
-        expect(out.sufficient).toBe(true);
-    });
-    it("long detailed brief (≥80 chars) with vague noun → scope NOT flagged", () => {
-        // 80+ chars carrying enough context that scope is implied even with 'app'.
-        const text = "Build a todo app with auth, multi-user support, postgres persistence, and a React + Vite frontend talking to a NestJS API";
-        const out = scoreSufficiency({ rawText: text });
-        expect(out.missing).not.toContain("scope");
-    });
-});
-describe("scoreSufficiency — edge cases", () => {
-    it("whitespace-only string treated as empty", () => {
-        const out = scoreSufficiency({ rawText: "   \n\t  " });
-        expect(out.sufficient).toBe(false);
-    });
-    it("repeated calls are idempotent (no FILE_REF_RE.lastIndex regression)", () => {
-        const text = "fix bug in src/index.ts";
-        const a = scoreSufficiency({ rawText: text });
-        const b = scoreSufficiency({ rawText: text });
-        expect(a.sufficient).toBe(b.sufficient);
-        expect(a.missing).toEqual(b.missing);
-    });
-    it("'build a counter' → sufficient (concrete verb 'add'-adjacent 'build' is NOT in verb list, but length < 30 + no scope-noun → intent)", () => {
-        // 'build' is not in CONCRETE_VERB_RE — intent only flagged if scope-noun AND file-ref AND verb all absent
-        // 'build a counter' (15 chars) lacks scope-noun, file-ref, concrete-verb → intent missing
-        const out = scoreSufficiency({ rawText: "build a counter" });
-        expect(out.sufficient).toBe(false);
-        expect(out.missing).toContain("intent");
-    });
-});
-//# sourceMappingURL=scoreSufficiency.test.js.map

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

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

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

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getPilLastResult, setPilLastResult } from "../store.js";
-// Reset module state between tests by re-importing via dynamic import won't work easily
-// Instead we use a helper pattern: call setPilLastResult(null as any) to reset
-// Actually we'll just rely on test order since the module is stateful
-const makeCtx = (raw) => ({
-    raw,
-    enriched: raw,
-    taskType: null,
-    domain: null,
-    confidence: 0,
-    outputStyle: null,
-    tokenBudget: 500,
-    metrics: null,
-    layers: [],
-});
-describe("PIL store", () => {
-    it("returns null before any call", () => {
-        // This only works if tests run in isolation or this is first test
-        // We test the getter returns null on a fresh import
-        // Since vitest reuses module state, we reset by calling set with null-like ctx
-        // For a clean null test, rely on fresh module state from vitest isolation
-        const initial = getPilLastResult();
-        // Accept either null (fresh) or whatever was set before
-        // The key invariant: after we set, we get back the same ctx
-        expect(initial === null || initial !== undefined).toBe(true);
-    });
-    it("setPilLastResult then getPilLastResult returns same ctx reference", () => {
-        const ctx = makeCtx("refactor this function");
-        setPilLastResult(ctx);
-        const result = getPilLastResult();
-        expect(result).toBe(ctx);
-    });
-    it("setPilLastResult called twice — second call overwrites first", () => {
-        const ctx1 = makeCtx("first prompt");
-        const ctx2 = makeCtx("second prompt");
-        setPilLastResult(ctx1);
-        setPilLastResult(ctx2);
-        const result = getPilLastResult();
-        expect(result).toBe(ctx2);
-        expect(result?.raw).toBe("second prompt");
-    });
-});
-//# sourceMappingURL=store.test.js.map

package/dist/src/pil/__tests__/surface-compaction-artifacts.test.d.ts

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

package/dist/src/pil/__tests__/surface-compaction-artifacts.test.js

@@ -1,112 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import { surfaceCompactionArtifacts } from "../layer3-ee-injection.js";
-// Issue #4 — targeted complement to layer3's checkpoint arm on meta turns.
-// layer3 (now run on meta after issue #2) surfaces checkpoints via a FIXED
-// recency query; this arm searches by the meta question (ctx.raw) to surface the
-// elided tool-artifacts relevant to it, and DEFERS when layer3 already injected a
-// checkpoint block. Mock the EE search + the audit log so the test stays offline.
-vi.mock("../../ee/bridge.js", () => ({
-    searchByText: vi.fn().mockResolvedValue([]),
-}));
-vi.mock("../../storage/interaction-log.js", () => ({
-    logInteraction: vi.fn(),
-}));
-import { searchByText } from "../../ee/bridge.js";
-function makeCtx(overrides = {}) {
-    return {
-        raw: "compaction cần cải thiện gì trong CLI",
-        enriched: "compaction cần cải thiện gì trong CLI",
-        taskType: "general",
-        domain: null,
-        confidence: 0.85,
-        outputStyle: "balanced",
-        tokenBudget: 2000,
-        metrics: null,
-        layers: [],
-        sessionId: "sess-meta-1",
-        ...overrides,
-    };
-}
-const artifactPoint = {
-    id: "art1",
-    score: 0.9,
-    payload: {
-        text: "tool-artifact id=call_7 toolName=read_file elided 4200 chars: src/orchestrator/compaction.ts createCompactionSummaryMessage ...",
-    },
-    collection: "experience-behavioral",
-};
-const checkpointPoint = {
-    id: "cp1",
-    score: 0.8,
-    payload: { text: "Context checkpoint summary ✔ DONE: extended IMPORTANT_TOOL_NAMES; tests 16/16" },
-    collection: "experience-behavioral",
-};
-const genericPoint = {
-    id: "gen1",
-    score: 0.97,
-    payload: { text: "Always run the full test suite before pushing" },
-    collection: "experience-behavioral",
-};
-describe("surfaceCompactionArtifacts (issue #4 — meta-turn auto-surface)", () => {
-    beforeEach(() => {
-        vi.mocked(searchByText).mockReset();
-        vi.mocked(searchByText).mockResolvedValue([]);
-    });
-    test("auto-surfaces [artifact] + checkpoint refs (and the rehydrate instruction) into enriched", async () => {
-        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
-        vi.mocked(searchByText).mockResolvedValue([artifactPoint, checkpointPoint]);
-        const ctx = makeCtx();
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toContain("[artifact]"); // artifact-typed line
-        expect(out.enriched).toContain("ee.query tool"); // how to rehydrate the full output
-        expect(out.enriched).toContain("call_7"); // the concrete tool-artifact id the agent can fetch
-        const layer = out.layers.find((l) => l.name === "ee-meta-artifacts");
-        expect(layer?.applied).toBe(true);
-        expect(layer?.delta).toContain("artifacts=2");
-        // Searches only the behavioral collection (where tool-artifacts are persisted).
-        expect(vi.mocked(searchByText)).toHaveBeenCalledWith(expect.stringContaining("tool-artifact"), ["experience-behavioral"], expect.any(Number), expect.any(Object));
-    });
-    test("no sessionId → unchanged, no EE call (no prior compaction to rehydrate)", async () => {
-        const ctx = makeCtx({ sessionId: undefined });
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toBe(ctx.enriched);
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("no-session");
-        expect(vi.mocked(searchByText)).not.toHaveBeenCalled();
-    });
-    test("search failure is fail-open + recorded (delta=error=…, enriched unchanged)", async () => {
-        vi.mocked(searchByText).mockRejectedValue(new Error("EE down"));
-        const ctx = makeCtx();
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toBe(ctx.enriched);
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toMatch(/^error=/);
-    });
-    test("generic behavioral hits are filtered out (not mislabelled as artifacts)", async () => {
-        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
-        vi.mocked(searchByText).mockResolvedValue([genericPoint]);
-        const ctx = makeCtx();
-        const out = await surfaceCompactionArtifacts(ctx);
-        expect(out.enriched).toBe(ctx.enriched);
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("no-artifacts");
-    });
-    test("defers to layer3 — skips with NO EE call when a checkpoint block is already present", async () => {
-        // layer3 ran first this turn and injected a checkpoint block (its marker is
-        // in enriched). The complement must not duplicate it or pay a 2nd round-trip.
-        const enriched = `${makeCtx().raw}\n[task checkpoints …]\n<!-- ee-checkpoint-injected:0123456789abcdef -->`;
-        const out = await surfaceCompactionArtifacts(makeCtx({ enriched }));
-        expect(out.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("already-surfaced");
-        expect(out.enriched).toBe(enriched); // unchanged
-        expect(vi.mocked(searchByText)).not.toHaveBeenCalled();
-    });
-    test("idempotent — a second pass on its own output defers (marker it wrote is seen)", async () => {
-        // biome-ignore lint/suspicious/noExplicitAny: test fixture shape mirrors EEPoint
-        vi.mocked(searchByText).mockResolvedValue([artifactPoint]);
-        const first = await surfaceCompactionArtifacts(makeCtx());
-        expect(first.enriched).toContain("[artifact]");
-        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(1);
-        const second = await surfaceCompactionArtifacts(makeCtx({ enriched: first.enriched }));
-        expect(second.layers.find((l) => l.name === "ee-meta-artifacts")?.delta).toBe("already-surfaced");
-        expect(second.enriched).toBe(first.enriched); // not grown a second time
-        expect(vi.mocked(searchByText)).toHaveBeenCalledTimes(1); // no second round-trip
-    });
-});
-//# sourceMappingURL=surface-compaction-artifacts.test.js.map

package/dist/src/pil/__tests__/task-tier-map.test.d.ts

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

package/dist/src/pil/__tests__/task-tier-map.test.js

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { taskTypeToTier } from "../task-tier-map.js";
-describe("taskTypeToTier — TaskType to EE tier mapping", () => {
-    it("maps 'refactor' to 'balanced'", () => {
-        expect(taskTypeToTier("refactor")).toBe("balanced");
-    });
-    it("maps 'debug' to 'balanced'", () => {
-        expect(taskTypeToTier("debug")).toBe("balanced");
-    });
-    it("maps 'plan' to 'premium'", () => {
-        expect(taskTypeToTier("plan")).toBe("premium");
-    });
-    it("maps 'analyze' to 'balanced'", () => {
-        expect(taskTypeToTier("analyze")).toBe("balanced");
-    });
-    it("maps 'documentation' to 'fast'", () => {
-        expect(taskTypeToTier("documentation")).toBe("fast");
-    });
-    it("maps 'generate' to 'balanced'", () => {
-        expect(taskTypeToTier("generate")).toBe("balanced");
-    });
-    it("maps 'general' to 'fast'", () => {
-        expect(taskTypeToTier("general")).toBe("fast");
-    });
-    it("maps null to 'fast'", () => {
-        expect(taskTypeToTier(null)).toBe("fast");
-    });
-    it("maps unknown string to 'balanced' (default fallback)", () => {
-        expect(taskTypeToTier("unknown")).toBe("balanced");
-        expect(taskTypeToTier("foobar")).toBe("balanced");
-    });
-});
-//# sourceMappingURL=task-tier-map.test.js.map

package/dist/src/pil/agent-operating-contract.test.d.ts

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