muonroi-cli 1.8.1 → 1.8.4

package/dist/src/ee/phase-tracker.test.js

@@ -1,142 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { _peekState, classifyOutcome, endPhase, markAborted, recordIntercept, recordPostTool, resetPhaseTracker, setPhase, } from "./phase-tracker.js";
-const refA = { collection: "code", pointId: "a" };
-const refB = { collection: "code", pointId: "b" };
-beforeEach(() => resetPhaseTracker());
-afterEach(() => resetPhaseTracker());
-describe("setPhase boundary semantics", () => {
-    it("returns null when starting from no active phase", () => {
-        expect(setPhase("implement")).toBeNull();
-        expect(_peekState()?.phaseName).toBe("implement");
-    });
-    it("returns null when called with the same phase", () => {
-        setPhase("implement");
-        expect(setPhase("implement")).toBeNull();
-    });
-    it("returns a snapshot when the phase name changes", () => {
-        setPhase("implement");
-        recordIntercept([refA]);
-        recordPostTool({ success: true, verifyResult: "pass" });
-        const snap = setPhase("verify");
-        expect(snap).not.toBeNull();
-        expect(snap.phaseName).toBe("implement");
-        expect(snap.principleRefs).toEqual([refA]);
-        expect(snap.verifyResult).toBe("pass");
-        expect(_peekState()?.phaseName).toBe("verify");
-    });
-    it("setPhase(null) ends the phase and returns a snapshot", () => {
-        setPhase("implement");
-        recordIntercept([refA]);
-        const snap = setPhase(null);
-        expect(snap?.phaseName).toBe("implement");
-        expect(_peekState()).toBeNull();
-    });
-});
-describe("recordIntercept", () => {
-    it("dedupes principle IDs across multiple intercepts in the same phase", () => {
-        setPhase("implement");
-        recordIntercept([refA]);
-        recordIntercept([refA, refB]);
-        const snap = endPhase();
-        expect(snap.principleRefs.map((r) => r.pointId).sort()).toEqual(["a", "b"]);
-        expect(snap.toolCount).toBe(2); // tool count increments per call
-    });
-    it("is a no-op when no phase is active", () => {
-        recordIntercept([refA]);
-        expect(_peekState()).toBeNull();
-    });
-    it("filters out malformed refs", () => {
-        setPhase("implement");
-        recordIntercept([
-            refA,
-            { collection: "", pointId: "no-coll" },
-            // @ts-expect-error null entry
-            null,
-        ]);
-        const snap = endPhase();
-        expect(snap.principleRefs).toEqual([refA]);
-    });
-});
-describe("recordPostTool", () => {
-    it("flags hadFailure on success=false", () => {
-        setPhase("implement");
-        recordPostTool({ success: false });
-        const snap = endPhase();
-        expect(snap.hadFailure).toBe(true);
-        expect(snap.verifyResult).toBeNull();
-    });
-    it("captures verifyResult", () => {
-        setPhase("verify");
-        recordPostTool({ success: true, verifyResult: "fail" });
-        const snap = endPhase();
-        expect(snap.verifyResult).toBe("fail");
-    });
-});
-describe("markAborted", () => {
-    it("sets aborted flag with reason", () => {
-        setPhase("implement");
-        markAborted("user-pressed-esc");
-        const snap = endPhase();
-        expect(snap.aborted).toBe(true);
-        expect(snap.abortReason).toBe("user-pressed-esc");
-    });
-    it("is a no-op when no phase active", () => {
-        markAborted("x");
-        expect(_peekState()).toBeNull();
-    });
-});
-describe("classifyOutcome", () => {
-    function snap(over) {
-        return {
-            phaseName: "implement",
-            startedAt: 0,
-            endedAt: 1,
-            toolCount: 0,
-            principleRefs: [],
-            verifyResult: null,
-            hadFailure: false,
-            aborted: false,
-            ...over,
-        };
-    }
-    it("aborted → abandoned", () => {
-        expect(classifyOutcome(snap({ aborted: true, verifyResult: "pass" }))).toBe("abandoned");
-    });
-    it("verifyResult=fail → fail", () => {
-        expect(classifyOutcome(snap({ verifyResult: "fail" }))).toBe("fail");
-    });
-    it("verifyResult=pass → pass", () => {
-        expect(classifyOutcome(snap({ verifyResult: "pass" }))).toBe("pass");
-    });
-    it("hadFailure alone returns null (insufficient signal)", () => {
-        expect(classifyOutcome(snap({ hadFailure: true }))).toBeNull();
-    });
-    it("nothing observed returns null", () => {
-        expect(classifyOutcome(snap({}))).toBeNull();
-    });
-});
-describe("end-to-end phase lifecycle", () => {
-    it("captures verify-pass workflow", () => {
-        // Turn 1: implement
-        setPhase("implement");
-        recordIntercept([refA, refB]);
-        recordPostTool({ success: true });
-        // Turn 2: verify (boundary)
-        const drained = setPhase("verify");
-        expect(drained.phaseName).toBe("implement");
-        expect(classifyOutcome(drained)).toBeNull(); // no verify outcome yet
-        recordPostTool({ success: true, verifyResult: "pass" });
-        // Turn 3: review (boundary again)
-        const drained2 = setPhase("review");
-        expect(drained2.phaseName).toBe("verify");
-        expect(classifyOutcome(drained2)).toBe("pass");
-    });
-    it("captures abort mid-phase as abandoned", () => {
-        setPhase("execute");
-        recordIntercept([refA]);
-        markAborted("user-pressed-esc");
-        const drained = endPhase();
-        expect(classifyOutcome(drained)).toBe("abandoned");
-    });
-});
-//# sourceMappingURL=phase-tracker.test.js.map

package/dist/src/ee/posttool.test.d.ts

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

package/dist/src/ee/posttool.test.js

@@ -1,70 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-// Mock both intercept and judge modules
-// posttool is now async — mock must return a Promise so await works correctly
-const mockPosttool = vi.fn().mockResolvedValue(undefined);
-vi.mock("./intercept.js", () => ({
-    getDefaultEEClient: () => ({
-        posttool: mockPosttool,
-    }),
-}));
-vi.mock("./judge.js", async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        fireFeedback: vi.fn(),
-    };
-});
-const mockPayload = {
-    toolName: "bash",
-    toolInput: { command: "ls" },
-    outcome: { success: true, exitCode: 0, durationMs: 10 },
-    cwd: "/tmp",
-    tenantId: "local",
-    scope: { kind: "global" },
-};
-describe("posttool() wrapper", () => {
-    it("calls client.posttool with payload", async () => {
-        mockPosttool.mockClear();
-        const { posttool } = await import("./posttool.js");
-        await posttool(mockPayload);
-        expect(mockPosttool).toHaveBeenCalledOnce();
-        expect(mockPosttool).toHaveBeenCalledWith(mockPayload);
-    });
-    it("calls fireFeedback when judgeCtx provided", async () => {
-        mockPosttool.mockClear();
-        const { posttool } = await import("./posttool.js");
-        const { fireFeedback } = await import("./judge.js");
-        const mockFF = fireFeedback;
-        mockFF.mockClear();
-        const ctx = {
-            warningResponse: { decision: "allow", matches: [] },
-            toolName: "bash",
-            outcome: { success: true, durationMs: 10 },
-            cwdMatchedAtPretool: true,
-            diffPresent: false,
-            tenantId: "local",
-        };
-        await posttool(mockPayload, ctx);
-        expect(mockPosttool).toHaveBeenCalledOnce();
-        expect(mockFF).toHaveBeenCalledOnce();
-        expect(mockFF).toHaveBeenCalledWith(ctx);
-    });
-    it("does not call fireFeedback when judgeCtx is undefined", async () => {
-        mockPosttool.mockClear();
-        const { posttool } = await import("./posttool.js");
-        const { fireFeedback } = await import("./judge.js");
-        const mockFF = fireFeedback;
-        mockFF.mockClear();
-        await posttool(mockPayload);
-        expect(mockPosttool).toHaveBeenCalledOnce();
-        expect(mockFF).not.toHaveBeenCalled();
-    });
-    it("returns Promise<void> (async — awaitable by PostToolUse handler)", async () => {
-        mockPosttool.mockClear();
-        const { posttool } = await import("./posttool.js");
-        const result = posttool(mockPayload);
-        expect(result).toBeInstanceOf(Promise);
-        await result; // resolves to undefined
-    });
-});
-//# sourceMappingURL=posttool.test.js.map

package/dist/src/ee/prompt-stale.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * src/ee/prompt-stale.test.ts
- *
- * Unit tests for reconcilePromptStale() fire-and-forget module.
- * Tests use vi.mock for getDefaultEEClient to inject mockPromptStale,
- * while using real updateLastSurfacedState/resetLastSurfacedState from intercept.ts.
- */
-export {};

package/dist/src/ee/prompt-stale.test.js

@@ -1,76 +0,0 @@
-/**
- * src/ee/prompt-stale.test.ts
- *
- * Unit tests for reconcilePromptStale() fire-and-forget module.
- * Tests use vi.mock for getDefaultEEClient to inject mockPromptStale,
- * while using real updateLastSurfacedState/resetLastSurfacedState from intercept.ts.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// Mock getDefaultEEClient to inject a controllable mockPromptStale
-vi.mock("./intercept.js", async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        getDefaultEEClient: vi.fn(),
-    };
-});
-import { getDefaultEEClient, getLastSurfacedState, resetLastSurfacedState, updateLastSurfacedState, } from "./intercept.js";
-import { reconcilePromptStale } from "./prompt-stale.js";
-describe("reconcilePromptStale", () => {
-    let mockPromptStale;
-    beforeEach(() => {
-        mockPromptStale = vi.fn().mockResolvedValue({ ok: true, unused: [], irrelevant: [], expired: [] });
-        vi.mocked(getDefaultEEClient).mockReturnValue({
-            promptStale: mockPromptStale,
-        });
-    });
-    afterEach(() => {
-        resetLastSurfacedState();
-        vi.clearAllMocks();
-    });
-    it("is a no-op when no surfaced IDs exist (does not call promptStale)", async () => {
-        // No call to updateLastSurfacedState — surfacedIds should be []
-        const result = reconcilePromptStale("/tmp");
-        // Flush microtasks
-        await new Promise((r) => setTimeout(r, 0));
-        expect(result).toBeUndefined();
-        expect(mockPromptStale).not.toHaveBeenCalled();
-    });
-    it("calls promptStale with correct payload when IDs are surfaced", async () => {
-        updateLastSurfacedState(["id-1", "id-2"]);
-        reconcilePromptStale("/tmp");
-        // Flush microtasks
-        await new Promise((r) => setTimeout(r, 0));
-        expect(mockPromptStale).toHaveBeenCalledTimes(1);
-        const [req] = mockPromptStale.mock.calls[0];
-        expect(req.state.surfacedIds).toEqual(["id-1", "id-2"]);
-        expect(typeof req.state.timestamp).toBe("string");
-        expect(req.nextPromptMeta.trigger).toBe("auto-compact");
-        expect(req.nextPromptMeta.cwd).toBe("/tmp");
-        expect(req.nextPromptMeta.tenantId).toBe("local");
-    });
-    it("returns undefined (void, not a Promise)", () => {
-        updateLastSurfacedState(["id-1"]);
-        const result = reconcilePromptStale("/tmp");
-        expect(result).toBeUndefined();
-    });
-    it("resets surfaced state BEFORE dispatching async HTTP call", async () => {
-        updateLastSurfacedState(["id-1", "id-2"]);
-        reconcilePromptStale("/tmp");
-        // Surfaced state should be reset synchronously before async dispatch
-        expect(getLastSurfacedState().surfacedIds).toEqual([]);
-        // HTTP call still dispatched (can verify via flush)
-        await new Promise((r) => setTimeout(r, 0));
-        expect(mockPromptStale).toHaveBeenCalledTimes(1);
-    });
-    it("swallows errors from rejected promptStale promise (fire-and-forget)", async () => {
-        mockPromptStale.mockRejectedValue(new Error("network error"));
-        updateLastSurfacedState(["id-1"]);
-        // Should not throw
-        expect(() => reconcilePromptStale("/tmp")).not.toThrow();
-        // Allow the rejected promise to settle — should not produce unhandled rejection
-        await new Promise((r) => setTimeout(r, 10));
-        expect(mockPromptStale).toHaveBeenCalledTimes(1);
-    });
-});
-//# sourceMappingURL=prompt-stale.test.js.map

package/dist/src/ee/recall-mirror.test.d.ts

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

package/dist/src/ee/recall-mirror.test.js

@@ -1,65 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { mirrorRecallLocally } from "./search.js";
-/**
- * mirrorRecallLocally writes an op:'recall' row matching the EE buildRecallEvent
- * shape into the client-local activity.jsonl, so the session-end runbook-candidate
- * nudge sees MCP/builtin recalls (not just exp-recall.js CLI recalls).
- */
-describe("mirrorRecallLocally", () => {
-    let dir;
-    let logPath;
-    beforeEach(() => {
-        dir = mkdtempSync(join(tmpdir(), "recall-mirror-"));
-        logPath = join(dir, "activity.jsonl");
-    });
-    afterEach(() => {
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("appends an op:recall row with surfacedIds derived from entries", async () => {
-        await mirrorRecallLocally("post donor enrich", {
-            sourceSession: "sess-1",
-            project: "storyflow",
-            entries: [
-                { id: "4c81b5ca", collection: "experience-selfqa" },
-                { id: "1e5f095f", collection: "experience-behavioral" },
-            ],
-        }, logPath);
-        const rows = readFileSync(logPath, "utf8")
-            .trim()
-            .split("\n")
-            .map((l) => JSON.parse(l));
-        expect(rows).toHaveLength(1);
-        expect(rows[0].op).toBe("recall");
-        expect(rows[0].query).toBe("post donor enrich");
-        expect(rows[0].sourceSession).toBe("sess-1");
-        expect(rows[0].project_slug).toBe("storyflow");
-        expect(rows[0].surfacedIds).toEqual(["4c81b5ca", "1e5f095f"]);
-        expect(rows[0].count).toBe(2);
-        expect(typeof rows[0].ts).toBe("string");
-    });
-    it("writes count 0 with empty entries (still observable, never throws)", async () => {
-        await mirrorRecallLocally("nothing matched", { sourceSession: null, project: null, entries: [] }, logPath);
-        const rows = readFileSync(logPath, "utf8")
-            .trim()
-            .split("\n")
-            .map((l) => JSON.parse(l));
-        expect(rows[0].count).toBe(0);
-        expect(rows[0].surfacedIds).toEqual([]);
-        expect(rows[0].sourceSession).toBeNull();
-    });
-    it("truncates an over-long query to 200 chars (matches buildRecallEvent)", async () => {
-        const long = "x".repeat(500);
-        await mirrorRecallLocally(long, { entries: [{ id: "a", collection: "c" }] }, logPath);
-        const row = JSON.parse(readFileSync(logPath, "utf8").trim());
-        expect(row.query.length).toBe(200);
-    });
-    it("never throws when the target path is unwritable (best-effort)", async () => {
-        // A path under a non-existent directory → appendFile rejects → swallowed.
-        const bad = join(dir, "nope", "deep", "activity.jsonl");
-        await expect(mirrorRecallLocally("q", { entries: [{ id: "a", collection: "c" }] }, bad)).resolves.toBeUndefined();
-    });
-});
-//# sourceMappingURL=recall-mirror.test.js.map

package/dist/src/ee/render.test.d.ts

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

package/dist/src/ee/render.test.js

@@ -1,63 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { emitMatches, renderInterceptWarning, setRenderSink } from "./render.js";
-const baseMatch = {
-    principle_uuid: "test-uuid-1234",
-    embedding_model_version: "nomic-embed-text-v1.5",
-    confidence: 0.85,
-    why: "It causes Y",
-    message: "Avoid editing X",
-    scope_label: "repo:foo/bar",
-    last_matched_at: "2026-04-30T00:00:00Z",
-};
-describe("renderInterceptWarning", () => {
-    it("renders 5-line boxed warning with confidence%, message, why, scope", () => {
-        const result = renderInterceptWarning(baseMatch);
-        const lines = result.split("\n");
-        expect(lines).toHaveLength(5);
-        expect(lines[0]).toContain("⚠ Experience Warning");
-        expect(lines[1]).toContain("85%");
-        expect(lines[1]).toContain("Avoid editing X");
-        expect(lines[2]).toContain("It causes Y");
-        expect(lines[3]).toContain("repo:foo/bar");
-        expect(lines[4]).toContain("└");
-    });
-    it("renders confidence as integer percentage (85% not 0.85)", () => {
-        expect(renderInterceptWarning(baseMatch)).toContain("85%");
-    });
-    it("renders confidence=1 as 100%", () => {
-        const match = { ...baseMatch, confidence: 1 };
-        expect(renderInterceptWarning(match)).toContain("100%");
-    });
-    it("renders confidence=0 as 0%", () => {
-        const match = { ...baseMatch, confidence: 0 };
-        expect(renderInterceptWarning(match)).toContain("[0%]");
-    });
-});
-describe("emitMatches + setRenderSink", () => {
-    let captured;
-    beforeEach(() => {
-        captured = [];
-        setRenderSink((chunk) => captured.push(chunk));
-    });
-    // emitMatches now emits StreamChunk objects; extract renderable content for assertions
-    const getContent = (c) => (typeof c === "string" ? c : (c?.content ?? JSON.stringify(c)));
-    it("emits each match via the sink", () => {
-        const matches = [
-            baseMatch,
-            { ...baseMatch, message: "Do not delete Z", why: "It breaks Q", confidence: 0.92 },
-        ];
-        emitMatches(matches);
-        expect(captured).toHaveLength(2);
-        expect(getContent(captured[0])).toContain("Avoid editing X");
-        expect(getContent(captured[1])).toContain("Do not delete Z");
-    });
-    it("does nothing for undefined matches", () => {
-        emitMatches(undefined);
-        expect(captured).toHaveLength(0);
-    });
-    it("does nothing for empty matches", () => {
-        emitMatches([]);
-        expect(captured).toHaveLength(0);
-    });
-});
-//# sourceMappingURL=render.test.js.map

package/dist/src/ee/scope.test.d.ts

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

package/dist/src/ee/scope.test.js

@@ -1,97 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-// We test the module under test after creating it
-import { buildScope, resetScopeCache, scopeLabel } from "./scope.js";
-describe("buildScope", () => {
-    let tmpDir;
-    beforeEach(async () => {
-        resetScopeCache();
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "scope-test-"));
-    });
-    afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
-    });
-    it("returns { kind: 'global' } for a directory without .git", async () => {
-        const scope = await buildScope({ cwd: tmpDir });
-        expect(scope).toEqual({ kind: "global" });
-    });
-    it("returns { kind: 'repo', remote } on detached HEAD with remote origin", async () => {
-        const gitDir = path.join(tmpDir, ".git");
-        await fs.mkdir(gitDir, { recursive: true });
-        await fs.writeFile(path.join(gitDir, "HEAD"), "abc123deadbeef\n");
-        await fs.writeFile(path.join(gitDir, "config"), '[remote "origin"]\n\turl = https://github.com/foo/bar.git\n');
-        const scope = await buildScope({ cwd: tmpDir });
-        expect(scope).toEqual({
-            kind: "repo",
-            remote: "https://github.com/foo/bar.git",
-        });
-    });
-    it("returns { kind: 'branch', remote, branch } when HEAD points to ref", async () => {
-        const gitDir = path.join(tmpDir, ".git");
-        await fs.mkdir(gitDir, { recursive: true });
-        await fs.writeFile(path.join(gitDir, "HEAD"), "ref: refs/heads/main\n");
-        await fs.writeFile(path.join(gitDir, "config"), '[remote "origin"]\n\turl = https://github.com/foo/bar.git\n');
-        const scope = await buildScope({ cwd: tmpDir });
-        expect(scope).toEqual({
-            kind: "branch",
-            remote: "https://github.com/foo/bar.git",
-            branch: "main",
-        });
-    });
-    it("reads .git/HEAD + .git/config via fs (no child_process spawn)", async () => {
-        // Verify the module source does not import child_process
-        const source = await fs.readFile(path.join(process.cwd(), "src/ee/scope.ts"), "utf8");
-        // Check for import/require of child_process (not just mentions in comments)
-        expect(source).not.toMatch(/import.*child_process/);
-        expect(source).not.toMatch(/require.*child_process/);
-        expect(source).not.toMatch(/import.*\bspawn\b/);
-        expect(source).not.toMatch(/import.*\bexec\b/);
-    });
-    it("caches: second call returns same object reference", async () => {
-        const gitDir = path.join(tmpDir, ".git");
-        await fs.mkdir(gitDir, { recursive: true });
-        await fs.writeFile(path.join(gitDir, "HEAD"), "ref: refs/heads/dev\n");
-        await fs.writeFile(path.join(gitDir, "config"), '[remote "origin"]\n\turl = https://github.com/a/b.git\n');
-        const first = await buildScope({ cwd: tmpDir });
-        const second = await buildScope({ cwd: tmpDir });
-        expect(first).toBe(second); // same reference
-    });
-    it("resetScopeCache forces re-read", async () => {
-        const gitDir = path.join(tmpDir, ".git");
-        await fs.mkdir(gitDir, { recursive: true });
-        await fs.writeFile(path.join(gitDir, "HEAD"), "ref: refs/heads/dev\n");
-        await fs.writeFile(path.join(gitDir, "config"), '[remote "origin"]\n\turl = https://github.com/a/b.git\n');
-        const first = await buildScope({ cwd: tmpDir });
-        resetScopeCache();
-        // Change the branch
-        await fs.writeFile(path.join(gitDir, "HEAD"), "ref: refs/heads/feature\n");
-        const second = await buildScope({ cwd: tmpDir });
-        expect(first).not.toBe(second);
-        expect(second).toEqual({
-            kind: "branch",
-            remote: "https://github.com/a/b.git",
-            branch: "feature",
-        });
-    });
-});
-describe("scopeLabel", () => {
-    it("formats global scope", () => {
-        expect(scopeLabel({ kind: "global" })).toBe("global");
-    });
-    it("formats ecosystem scope", () => {
-        expect(scopeLabel({ kind: "ecosystem", name: "muonroi" })).toBe("ecosystem:muonroi");
-    });
-    it("formats repo scope", () => {
-        expect(scopeLabel({ kind: "repo", remote: "https://github.com/x/y" })).toBe("repo:https://github.com/x/y");
-    });
-    it("formats branch scope", () => {
-        expect(scopeLabel({
-            kind: "branch",
-            remote: "https://github.com/x/y",
-            branch: "main",
-        })).toBe("branch:https://github.com/x/y#main");
-    });
-});
-//# sourceMappingURL=scope.test.js.map

package/dist/src/ee/search.test.d.ts

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

package/dist/src/ee/search.test.js

@@ -1,23 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { setDefaultEEClient } from "./intercept.js";
-import { searchEE } from "./search.js";
-// Issue #3 seam: searchEE used to build a FRESH createEEClient, so the artifact
-// READ leg (ee_query "tool-artifact id=X") could not be intercepted by
-// setDefaultEEClient — while the WRITE leg (persistArtifact → getDefaultEEClient
-// .extract) could. Routing searchEE through getDefaultEEClient unifies the seam:
-// one injected client now intercepts both legs (testable end-to-end + the spot a
-// durability fallback can hook).
-describe("searchEE — routes through the injectable default EE client", () => {
-    afterEach(() => {
-        setDefaultEEClient(null); // teardown → next getDefaultEEClient lazy-inits a real one
-    });
-    it("uses getDefaultEEClient().search so the artifact READ leg is interceptable", async () => {
-        const fakeResp = { results: [{ id: "x", text: "REHYDRATED" }] };
-        const search = vi.fn().mockResolvedValue(fakeResp);
-        setDefaultEEClient({ search });
-        const out = await searchEE("tool-artifact id=x", { collections: ["experience-behavioral"], limit: 1 });
-        expect(search).toHaveBeenCalledWith("tool-artifact id=x", { collections: ["experience-behavioral"], limit: 1 });
-        expect(out).toBe(fakeResp);
-    });
-});
-//# sourceMappingURL=search.test.js.map

package/dist/src/ee/session-trajectory.test.d.ts

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