muonroi-cli 1.8.0 → 1.8.3

package/dist/src/ee/__tests__/export-transcripts.test.js

@@ -1,200 +0,0 @@
-/**
- * export-transcripts.test.ts
- *
- * Unit tests for exportTranscripts() — SQLite → JSONL transcript export.
- *
- * Strategy: redirect USERPROFILE (Windows) / HOME (POSIX) to a temp dir,
- * create a real SQLite DB at `~/.muonroi-cli/muonroi.db`, and call the
- * function.  Also creates `~/.experience/config.json` so the emit sidecar
- * (transcript-emit) does not gate-return null.
- */
-import { Database } from "bun:sqlite";
-// @ts-expect-error — bun:test is provided by the bun runtime; this file runs
-// via `bun test`, not vitest (vitest cannot resolve bun:sqlite's `db.run` API).
-// Excluded from vitest in vitest.config.ts.
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-let tmpHome = "";
-let origUserProfile;
-function cleanDb() {
-    if (tmpHome) {
-        try {
-            rmSync(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-        }
-        catch {
-            /* ok */
-        }
-    }
-}
-function bootstrapDb(sessions) {
-    const dbDir = join(tmpHome, ".muonroi-cli");
-    const dbPath = join(dbDir, "muonroi.db");
-    mkdirSync(dbDir, { recursive: true });
-    const db = new Database(dbPath, { create: true });
-    db.run("CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, updated_at TEXT NOT NULL, cwd_last TEXT DEFAULT NULL)");
-    db.run("CREATE TABLE IF NOT EXISTS messages (session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE, seq INTEGER NOT NULL, role TEXT NOT NULL, message_json TEXT NOT NULL, created_at TEXT DEFAULT NULL, status TEXT DEFAULT NULL)");
-    for (const s of sessions) {
-        db.run("INSERT INTO sessions (id, updated_at, cwd_last) VALUES (?, ?, ?)", [s.sessionId, s.updatedAt, s.cwdLast]);
-        for (const m of s.messages) {
-            db.run("INSERT INTO messages (session_id, seq, role, message_json) VALUES (?, ?, ?, ?)", [
-                s.sessionId,
-                m.seq,
-                m.role,
-                m.messageJson,
-            ]);
-        }
-    }
-    db.close();
-}
-beforeEach(() => {
-    tmpHome = join(tmpdir(), `muonroi-test-export-${Date.now()}`);
-    const muonroiDir = join(tmpHome, ".muonroi-cli");
-    const experienceDir = join(tmpHome, ".experience");
-    mkdirSync(muonroiDir, { recursive: true });
-    mkdirSync(experienceDir, { recursive: true });
-    // Create a minimal config so transcript-emit's isEnabled() returns true.
-    writeFileSync(join(experienceDir, "config.json"), JSON.stringify({}), "utf-8");
-    origUserProfile = process.env.USERPROFILE;
-    process.env.USERPROFILE = tmpHome;
-});
-afterEach(() => {
-    cleanDb();
-    if (origUserProfile !== undefined)
-        process.env.USERPROFILE = origUserProfile;
-    else
-        delete process.env.USERPROFILE;
-});
-// ── tests ────────────────────────────────────────────────────────────
-describe("exportTranscripts", () => {
-    it("no DB file → throws", async () => {
-        // No bootstrapDb call — DB doesn't exist.
-        const mod = await import("../export-transcripts.js");
-        await expect(mod.exportTranscripts()).rejects.toThrow();
-    });
-    it("dry-run with 0 sessions => empty result", async () => {
-        await bootstrapDb([]);
-        const mod = await import("../export-transcripts.js");
-        const res = await mod.exportTranscripts({ dryRun: true });
-        expect(res.totalSessions).toBe(0);
-        expect(res.written).toBe(0);
-        expect(res.skippedEmpty).toBe(0);
-        expect(res.skippedTooSmall).toBe(0);
-    });
-    it("dry-run emits sessions with >= 4 messages", async () => {
-        await bootstrapDb([
-            {
-                sessionId: "sess-1",
-                updatedAt: new Date().toISOString(),
-                cwdLast: null,
-                messages: [
-                    { seq: 1, role: "user", messageJson: JSON.stringify({ content: "hi" }) },
-                    { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "there" }) },
-                    { seq: 3, role: "user", messageJson: JSON.stringify({ content: "again" }) },
-                    { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "bye" }) },
-                ],
-            },
-        ]);
-        const mod = await import("../export-transcripts.js");
-        const res = await mod.exportTranscripts({ dryRun: true });
-        expect(res.totalSessions).toBe(1);
-        expect(res.written).toBe(1);
-        expect(res.skippedEmpty).toBe(0);
-        expect(res.skippedTooSmall).toBe(0);
-    });
-    it("wet-run writes JSONL files", async () => {
-        await bootstrapDb([
-            {
-                sessionId: "sess-1",
-                updatedAt: new Date().toISOString(),
-                cwdLast: null,
-                messages: [
-                    { seq: 1, role: "user", messageJson: JSON.stringify({ content: "hi" }) },
-                    { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "there" }) },
-                    { seq: 3, role: "user", messageJson: JSON.stringify({ content: "again" }) },
-                    { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "bye" }) },
-                ],
-            },
-        ]);
-        const mod = await import("../export-transcripts.js");
-        const res = await mod.exportTranscripts({ dryRun: false });
-        expect(res.totalSessions).toBe(1);
-        expect(res.written).toBe(1);
-        expect(res.skippedEmpty).toBe(0);
-        expect(res.skippedTooSmall).toBe(0);
-    });
-    it("skips sessions past maxAgeDays", async () => {
-        const old = new Date(Date.now() - 100 * 86400_000).toISOString();
-        await bootstrapDb([
-            {
-                sessionId: "sess-old",
-                updatedAt: old,
-                cwdLast: null,
-                messages: [
-                    { seq: 1, role: "user", messageJson: JSON.stringify({ content: "old1" }) },
-                    { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "old resp1" }) },
-                    { seq: 3, role: "user", messageJson: JSON.stringify({ content: "old2" }) },
-                    { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "old resp2" }) },
-                ],
-            },
-        ]);
-        const mod = await import("../export-transcripts.js");
-        const res = await mod.exportTranscripts({ dryRun: true, maxAgeDays: 7 });
-        expect(res.totalSessions).toBe(0);
-        expect(res.written).toBe(0);
-    });
-    it("skips sessions with too few messages", async () => {
-        await bootstrapDb([
-            {
-                sessionId: "sess-small",
-                updatedAt: new Date().toISOString(),
-                cwdLast: null,
-                messages: [{ seq: 1, role: "user", messageJson: JSON.stringify({ content: "only" }) }],
-            },
-        ]);
-        const mod = await import("../export-transcripts.js");
-        // Default minMessages = 4
-        const res = await mod.exportTranscripts({ dryRun: true });
-        expect(res.totalSessions).toBe(1);
-        expect(res.written).toBe(0);
-        expect(res.skippedTooSmall).toBe(1);
-    });
-    it("skippedEmpty when messages table returns nothing for a matched session", async () => {
-        await bootstrapDb([
-            {
-                sessionId: "sess-empty",
-                updatedAt: new Date().toISOString(),
-                cwdLast: null,
-                messages: [],
-            },
-        ]);
-        const mod = await import("../export-transcripts.js");
-        const res = await mod.exportTranscripts({ dryRun: true, maxAgeDays: 30 });
-        expect(res.totalSessions).toBe(1);
-        expect(res.written).toBe(0);
-        expect(res.skippedEmpty).toBe(1);
-    });
-    it("bad JSON in message_json row — throws by default", async () => {
-        await bootstrapDb([
-            {
-                sessionId: "sess-bad",
-                updatedAt: new Date().toISOString(),
-                cwdLast: null,
-                messages: [{ seq: 1, role: "user", messageJson: "NOT_VALID_JSON" }],
-            },
-        ]);
-        const mod = await import("../export-transcripts.js");
-        // The function's inner callback in .map() wraps JSON.parse in try/catch
-        // and returns null on failure. With null row messages.length<minMessages
-        // so it falls through to skippedTooSmall. This is intentional per source.
-        const res = await mod.exportTranscripts({ dryRun: true, minMessages: 1 });
-        // minMessages=1, but the single row's parse fails → messages.length=0
-        // -> skippedEmpty not skippedTooSmall
-        expect(res.totalSessions).toBe(1);
-        expect(res.written).toBe(0);
-        expect(res.skippedEmpty).toBe(1);
-        expect(res.skippedTooSmall).toBe(0);
-    });
-});
-//# sourceMappingURL=export-transcripts.test.js.map

package/dist/src/ee/__tests__/pil-context-bridge.test.d.ts

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

package/dist/src/ee/__tests__/pil-context-bridge.test.js

@@ -1,54 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { pilContext, resetPilContextCircuit } from "../bridge.js";
-vi.mock("../client-mode.js", () => ({
-    getCachedEEClientMode: () => ({ mode: "thin", baseUrl: "https://stub", token: "x" }),
-}));
-vi.mock("../auth.js", () => ({ getCachedServerBaseUrl: () => "https://stub" }));
-const mockClient = vi.hoisted(() => ({ pilContext: vi.fn() }));
-vi.mock("../intercept.js", () => ({ getDefaultEEClient: () => mockClient }));
-describe("pilContext bridge wrapper", () => {
-    beforeEach(() => {
-        mockClient.pilContext.mockReset();
-        resetPilContextCircuit();
-    });
-    it("returns parsed response when client succeeds", async () => {
-        mockClient.pilContext.mockResolvedValueOnce({
-            taskType: "debug",
-            intentKind: "task",
-            outputStyle: "balanced",
-            confidence: 0.8,
-            domain: null,
-            gsd_phase: null,
-            gsd_route_source: "none",
-            t0_principles: [],
-            t1_rules: [],
-            t2_patterns: [],
-            retrieval_skipped_reason: null,
-            cache_hit: false,
-            inference_ms: 100,
-            schema_version: "1.0",
-        });
-        const result = await pilContext("test prompt");
-        expect(result?.taskType).toBe("debug");
-    });
-    it("returns null on schema reject", async () => {
-        mockClient.pilContext.mockResolvedValueOnce({ taskType: "debug" }); // missing required fields
-        const result = await pilContext("test");
-        expect(result).toBeNull();
-    });
-    it("returns null on client failure", async () => {
-        mockClient.pilContext.mockResolvedValueOnce(null);
-        const result = await pilContext("test");
-        expect(result).toBeNull();
-    });
-    it("circuit opens after 5 failures in 30s, short-circuits 6th call", async () => {
-        mockClient.pilContext.mockResolvedValue(null);
-        for (let i = 0; i < 5; i++)
-            await pilContext("test");
-        mockClient.pilContext.mockClear();
-        const result = await pilContext("test");
-        expect(result).toBeNull();
-        expect(mockClient.pilContext).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=pil-context-bridge.test.js.map

package/dist/src/ee/__tests__/pipeline.integration.test.d.ts

@@ -1,14 +0,0 @@
-/**
- * End-to-end pipeline integration test (ROUTE-12).
- *
- * Verifies all 5 events fire for a single tool invocation:
- *   PreToolUse (intercept) -> PostToolUse (posttool) -> Judge -> Feedback -> Touch
- *
- * Uses real modules + stub HTTP server — no vi.mock.
- * Anti-patterns avoided:
- *   - No HTTP call ordering by array index (fire-and-forget lands non-deterministically)
- *   - resetEEClientState() in beforeEach (circuit breaker + cache contamination)
- *   - resetHookState() in beforeEach (_lastWarningResponse contamination between tests)
- *   - No vi.mock — integration test uses real modules + stub
- */
-export {};

package/dist/src/ee/__tests__/pipeline.integration.test.js

@@ -1,151 +0,0 @@
-/**
- * End-to-end pipeline integration test (ROUTE-12).
- *
- * Verifies all 5 events fire for a single tool invocation:
- *   PreToolUse (intercept) -> PostToolUse (posttool) -> Judge -> Feedback -> Touch
- *
- * Uses real modules + stub HTTP server — no vi.mock.
- * Anti-patterns avoided:
- *   - No HTTP call ordering by array index (fire-and-forget lands non-deterministically)
- *   - resetEEClientState() in beforeEach (circuit breaker + cache contamination)
- *   - resetHookState() in beforeEach (_lastWarningResponse contamination between tests)
- *   - No vi.mock — integration test uses real modules + stub
- */
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { startStubEEServer } from "../../__test-stubs__/ee-server.js";
-import { executeEventHooks, resetHookState } from "../../hooks/index.js";
-import { createEEClient, resetEEClientState } from "../client.js";
-import { setDefaultEEClient } from "../intercept.js";
-const sampleMatch = {
-    principle_uuid: "P1",
-    confidence: 0.9,
-    why: "test match",
-    message: "warning: test principle",
-    embedding_model_version: "v1",
-    scope_label: "global",
-    last_matched_at: new Date().toISOString(),
-};
-describe("EE full pipeline integration (ROUTE-12)", () => {
-    let stub;
-    beforeEach(async () => {
-        resetEEClientState();
-        resetHookState();
-    });
-    afterEach(async () => {
-        if (stub)
-            await stub.stop();
-        resetEEClientState();
-        resetHookState();
-    });
-    it("fires all 5 events for a single tool invocation (intercept -> posttool -> judge -> feedback -> touch)", async () => {
-        stub = await startStubEEServer({
-            intercept: () => ({
-                decision: "allow",
-                matches: [sampleMatch],
-            }),
-        });
-        const client = createEEClient({
-            baseUrl: `http://127.0.0.1:${stub.port}`,
-            timeoutMs: 2000,
-        });
-        setDefaultEEClient(client);
-        // Event 1: PreToolUse — fires intercept, stores warning in _lastWarningResponse
-        await executeEventHooks({
-            hook_event_name: "PreToolUse",
-            tool_name: "Edit",
-            tool_input: { path: "/tmp/x.ts" },
-            cwd: process.cwd(),
-        }, process.cwd());
-        // Event 2: PostToolUse — fires posttool + (judge -> feedback + touch via judgeCtx)
-        await executeEventHooks({
-            hook_event_name: "PostToolUse",
-            tool_name: "Edit",
-            tool_input: { path: "/tmp/x.ts" },
-            tool_output: { result: "ok" },
-            cwd: process.cwd(),
-        }, process.cwd());
-        // Allow fire-and-forget HTTP calls (feedback + touch) to settle
-        await new Promise((r) => setTimeout(r, 500));
-        // Assert all 5 pipeline stages fired
-        expect(stub.calls.intercept).toHaveLength(1); // Stage 1: PreToolUse
-        expect(stub.calls.posttool).toHaveLength(1); // Stage 2: PostToolUse
-        expect(stub.calls.feedback.length).toBeGreaterThanOrEqual(1); // Stage 3+4: Judge FOLLOWED -> Feedback
-        expect(stub.calls.touch.length).toBeGreaterThanOrEqual(1); // Stage 5: Touch (FOLLOWED path)
-        // Verify feedback classification
-        expect(stub.calls.feedback[0]).toMatchObject({
-            principle_uuid: "P1",
-            classification: "FOLLOWED",
-            tool_name: "Edit",
-        });
-    });
-    it("auto-judge classifies IRRELEVANT when no matches — feedback and touch not called", async () => {
-        stub = await startStubEEServer({
-            intercept: () => ({
-                decision: "allow",
-                matches: [], // empty matches => IRRELEVANT
-            }),
-        });
-        const client = createEEClient({
-            baseUrl: `http://127.0.0.1:${stub.port}`,
-            timeoutMs: 2000,
-        });
-        setDefaultEEClient(client);
-        await executeEventHooks({
-            hook_event_name: "PreToolUse",
-            tool_name: "Edit",
-            tool_input: { path: "/tmp/y.ts" },
-            cwd: process.cwd(),
-        }, process.cwd());
-        await executeEventHooks({
-            hook_event_name: "PostToolUse",
-            tool_name: "Edit",
-            tool_input: { path: "/tmp/y.ts" },
-            tool_output: { result: "ok" },
-            cwd: process.cwd(),
-        }, process.cwd());
-        await new Promise((r) => setTimeout(r, 150));
-        // intercept + posttool fire, but no feedback or touch (IRRELEVANT has no matches to report)
-        expect(stub.calls.intercept).toHaveLength(1);
-        expect(stub.calls.posttool).toHaveLength(1);
-        expect(stub.calls.feedback).toHaveLength(0); // IRRELEVANT: judge.ts line 33 — no feedback for empty matches
-        expect(stub.calls.touch).toHaveLength(0);
-    });
-    it("auto-judge classifies IGNORED when outcome fails — feedback called, touch not called", async () => {
-        stub = await startStubEEServer({
-            intercept: () => ({
-                decision: "allow",
-                matches: [sampleMatch],
-            }),
-        });
-        const client = createEEClient({
-            baseUrl: `http://127.0.0.1:${stub.port}`,
-            timeoutMs: 2000,
-        });
-        setDefaultEEClient(client);
-        // PreToolUse to populate _lastWarningResponse with matches
-        await executeEventHooks({
-            hook_event_name: "PreToolUse",
-            tool_name: "Bash",
-            tool_input: { command: "exit 1" },
-            cwd: process.cwd(),
-        }, process.cwd());
-        // PostToolUseFailure — outcome.success=false => IGNORED classification
-        await executeEventHooks({
-            hook_event_name: "PostToolUseFailure",
-            tool_name: "Bash",
-            tool_input: { command: "exit 1" },
-            error: "exit code 1",
-            cwd: process.cwd(),
-        }, process.cwd());
-        await new Promise((r) => setTimeout(r, 150));
-        expect(stub.calls.intercept).toHaveLength(1);
-        expect(stub.calls.posttool).toHaveLength(1);
-        expect(stub.calls.feedback).toHaveLength(1); // IGNORED: feedback fires
-        expect(stub.calls.touch).toHaveLength(0); // IGNORED: touch does NOT fire
-        expect(stub.calls.feedback[0]).toMatchObject({
-            principle_uuid: "P1",
-            classification: "IGNORED",
-        });
-    });
-});
-//# sourceMappingURL=pipeline.integration.test.js.map

package/dist/src/ee/__tests__/recall-format.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * formatRecallForAgent — compact, capped, inline-readable recall index.
- *
- * Locks the fix for the MCP/builtin ee_query overflow: the recallMode pipeline
- * returns ~30k of ranked text, and the old `JSON.stringify(resp)` path blew the
- * MCP per-result token cap (forcing a file spill) and JSON-escaped the index.
- * This formatter returns the raw ranked text, capped on a line boundary, with a
- * count + truncation footer and every `[id col]` handle in the kept region intact.
- */
-export {};

package/dist/src/ee/__tests__/recall-format.test.js

@@ -1,57 +0,0 @@
-/**
- * formatRecallForAgent — compact, capped, inline-readable recall index.
- *
- * Locks the fix for the MCP/builtin ee_query overflow: the recallMode pipeline
- * returns ~30k of ranked text, and the old `JSON.stringify(resp)` path blew the
- * MCP per-result token cap (forcing a file spill) and JSON-escaped the index.
- * This formatter returns the raw ranked text, capped on a line boundary, with a
- * count + truncation footer and every `[id col]` handle in the kept region intact.
- */
-import { describe, expect, it } from "vitest";
-import { formatRecallForAgent } from "../search.js";
-function resp(text, count) {
-    return { text, count, entries: [] };
-}
-describe("formatRecallForAgent", () => {
-    it("returns the ranked index plus a count footer when it fits", () => {
-        const out = formatRecallForAgent(resp("- lesson one [id:abc col:experience-behavioral]", 1), { query: "redactor" });
-        expect(out).toContain("[id:abc col:experience-behavioral]");
-        expect(out).toContain('[recall: 1 entries for "redactor"]');
-        expect(out).not.toContain("\\n"); // raw text, not JSON-escaped
-    });
-    it("reports zero entries (and never dumps) when nothing matched", () => {
-        expect(formatRecallForAgent(resp(null, 0), { query: "nope" })).toBe('[recall: 0 entries for "nope" — the brain has nothing here; proceed without it.]');
-        expect(formatRecallForAgent(resp("ignored stale text", 0))).toContain("0 entries");
-    });
-    it("caps oversized text and marks it truncated", () => {
-        const big = `${"x".repeat(50_000)}`;
-        const out = formatRecallForAgent(resp(big, 99), { maxChars: 6000, query: "wide" });
-        expect(out.length).toBeLessThan(6500); // body cap + short footer
-        expect(out).toContain("truncated");
-        expect(out).toContain("/50000 chars");
-        expect(out).toContain("99 entries");
-    });
-    it("cuts on a line boundary so a [id col] handle is never split", () => {
-        // Padded so each line clears the 500-char clamp floor; budget lands inside
-        // line C → line C is dropped whole rather than split mid-handle.
-        const pad = "z".repeat(280);
-        const lineA = `${pad} [id:a col:x]`;
-        const lineB = `${pad} [id:b col:y]`;
-        const lineC = `${pad} [id:c col:z]`;
-        const text = [lineA, lineB, lineC].join("\n");
-        const cInner = text.indexOf("[id:c col:z]") + 4; // mid-line-C, after the last newline
-        const out = formatRecallForAgent(resp(text, 3), { maxChars: cInner });
-        expect(out).toContain("[id:a col:x]");
-        expect(out).toContain("[id:b col:y]");
-        expect(out).not.toContain("[id:c col:z]"); // dropped whole, not a dangling partial
-        expect(out).toContain("truncated");
-    });
-    it("clamps maxChars into [500, 20000]", () => {
-        const text = "y".repeat(30_000);
-        const tiny = formatRecallForAgent(resp(text, 1), { maxChars: 1 }); // clamped up to 500
-        const bodyLen = tiny.split("\n\n")[0].length;
-        expect(bodyLen).toBeGreaterThanOrEqual(500);
-        expect(bodyLen).toBeLessThanOrEqual(20_000);
-    });
-});
-//# sourceMappingURL=recall-format.test.js.map

package/dist/src/ee/__tests__/recall-ledger.test.d.ts

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

package/dist/src/ee/__tests__/recall-ledger.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createRecallLedger } from "../recall-ledger.js";
-describe("recall-ledger", () => {
-    it("records entries as pending and counts them", () => {
-        const l = createRecallLedger();
-        l.record([
-            { id: "a", collection: "c1" },
-            { id: "b", collection: null },
-        ], "q1");
-        expect(l.pendingCount()).toBe(2);
-        const pending = l.pending();
-        expect(pending.map((p) => p.id)).toEqual(["a", "b"]);
-        expect(pending[0].query).toBe("q1");
-    });
-    it("first sighting wins — re-recording an unrated id keeps the original query", () => {
-        const l = createRecallLedger();
-        l.record([{ id: "a", collection: "c1" }], "first");
-        l.record([{ id: "a", collection: "c1" }], "second");
-        expect(l.pendingCount()).toBe(1);
-        expect(l.pending()[0].query).toBe("first");
-    });
-    it("clear() removes a rated id and reports whether it was pending", () => {
-        const l = createRecallLedger();
-        l.record([{ id: "a", collection: "c1" }], "q");
-        expect(l.clear("a")).toBe(true);
-        expect(l.clear("a")).toBe(false); // already gone
-        expect(l.pendingCount()).toBe(0);
-    });
-    it("ignores entries with empty/missing ids and non-array input", () => {
-        const l = createRecallLedger();
-        l.record([
-            { id: "", collection: "c" },
-            { id: "  ", collection: "c" },
-        ], "q");
-        l.record(undefined, "q");
-        expect(l.pendingCount()).toBe(0);
-    });
-    it("reset() empties the ledger", () => {
-        const l = createRecallLedger();
-        l.record([{ id: "a", collection: "c" }], "q");
-        l.reset();
-        expect(l.pendingCount()).toBe(0);
-    });
-});
-//# sourceMappingURL=recall-ledger.test.js.map

package/dist/src/ee/__tests__/render-sink-wiring.test.d.ts

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

package/dist/src/ee/__tests__/render-sink-wiring.test.js

@@ -1,74 +0,0 @@
-/**
- * render-sink-wiring.test.ts
- *
- * CQ-16a regression tests: emitMatches emits StreamChunk (not string) through custom sink.
- * Verifies observable behaviors locked after Wave 1-2 render.ts changes.
- */
-import { beforeEach, describe, expect, it } from "vitest";
-import { emitMatches, getRenderSink, setRenderSink, warningToChunk } from "../render.js";
-const FAKE_MATCH = {
-    confidence: 0.85,
-    message: "Test warning",
-    why: "Because test",
-    scope_label: "global",
-    principle_uuid: "test-uuid-123",
-    embedding_model_version: "nomic-embed-text-v1.5",
-    last_matched_at: "2026-05-08T00:00:00Z",
-};
-describe("render-sink-wiring (CQ-16a)", () => {
-    beforeEach(() => {
-        // Reset to default sink to avoid test pollution
-        setRenderSink((lineOrChunk) => {
-            if (typeof lineOrChunk === "string")
-                console.warn(lineOrChunk);
-        });
-    });
-    it("emitMatches sends experience_warning StreamChunk through custom sink", () => {
-        const captured = [];
-        setRenderSink((c) => captured.push(c));
-        emitMatches([FAKE_MATCH]);
-        expect(captured).toHaveLength(1);
-        const chunk = captured[0];
-        expect(chunk.type).toBe("experience_warning");
-    });
-    it("emitMatches chunk carries experienceWarning payload", () => {
-        const captured = [];
-        setRenderSink((c) => captured.push(c));
-        emitMatches([FAKE_MATCH]);
-        const w = captured[0]?.experienceWarning;
-        expect(w).toBeDefined();
-        expect(w?.confidence).toBe(0.85);
-        expect(w?.principleUuid).toBe("test-uuid-123");
-        expect(w?.message).toBe("Test warning");
-    });
-    it("emitMatches with undefined does not call sink", () => {
-        let called = false;
-        setRenderSink(() => {
-            called = true;
-        });
-        emitMatches(undefined);
-        expect(called).toBe(false);
-    });
-    it("emitMatches with empty array does not call sink", () => {
-        let called = false;
-        setRenderSink(() => {
-            called = true;
-        });
-        emitMatches([]);
-        expect(called).toBe(false);
-    });
-    it("warningToChunk returns experience_warning StreamChunk with full payload", () => {
-        const chunk = warningToChunk(FAKE_MATCH);
-        expect(chunk.type).toBe("experience_warning");
-        expect(chunk.experienceWarning?.confidence).toBe(0.85);
-        expect(chunk.experienceWarning?.why).toBe("Because test");
-        expect(chunk.experienceWarning?.scopeLabel).toBe("global");
-        expect(chunk.experienceWarning?.principleUuid).toBe("test-uuid-123");
-    });
-    it("setRenderSink + getRenderSink roundtrip works", () => {
-        const myFn = () => { };
-        setRenderSink(myFn);
-        expect(getRenderSink()).toBe(myFn);
-    });
-});
-//# sourceMappingURL=render-sink-wiring.test.js.map

package/dist/src/ee/artifact-cache.test.d.ts

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