muonroi-cli 1.8.1 → 1.8.4

package/dist/src/usage/midstream.test.js

@@ -1,47 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { midstreamPolicy } from "./midstream.js";
-import { emit } from "./thresholds.js";
-describe("midstreamPolicy", () => {
-    beforeEach(() => {
-        midstreamPolicy.clear();
-    });
-    it("refuseNext() is false initially", () => {
-        expect(midstreamPolicy.refuseNext()).toBe(false);
-    });
-    it("refuseNext() flips to true after {level:100} threshold event", () => {
-        const ev = {
-            level: 100,
-            current_pct: 100,
-            current_usd: 15,
-            cap_usd: 15,
-            atMs: Date.now(),
-        };
-        emit(ev);
-        expect(midstreamPolicy.refuseNext()).toBe(true);
-    });
-    it("does NOT flip on {level:50} or {level:80}", () => {
-        emit({ level: 50, current_pct: 50, current_usd: 7.5, cap_usd: 15, atMs: Date.now() });
-        expect(midstreamPolicy.refuseNext()).toBe(false);
-        emit({ level: 80, current_pct: 80, current_usd: 12, cap_usd: 15, atMs: Date.now() });
-        expect(midstreamPolicy.refuseNext()).toBe(false);
-    });
-    it("isStreamFinishAllowed() always returns true (in-flight finishes)", () => {
-        expect(midstreamPolicy.isStreamFinishAllowed()).toBe(true);
-        // Even after 100% breach
-        emit({ level: 100, current_pct: 101, current_usd: 15.15, cap_usd: 15, atMs: Date.now() });
-        expect(midstreamPolicy.isStreamFinishAllowed()).toBe(true);
-    });
-    it("currentPct() tracks the latest threshold event pct", () => {
-        expect(midstreamPolicy.currentPct()).toBe(0);
-        emit({ level: 50, current_pct: 52.3, current_usd: 7.8, cap_usd: 15, atMs: Date.now() });
-        expect(midstreamPolicy.currentPct()).toBeCloseTo(52.3);
-    });
-    it("clear() resets state (for tests + month rollover)", () => {
-        midstreamPolicy.forceRefuseNext();
-        expect(midstreamPolicy.refuseNext()).toBe(true);
-        midstreamPolicy.clear();
-        expect(midstreamPolicy.refuseNext()).toBe(false);
-        expect(midstreamPolicy.currentPct()).toBe(0);
-    });
-});
-//# sourceMappingURL=midstream.test.js.map

package/dist/src/usage/thresholds.test.d.ts

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

package/dist/src/usage/thresholds.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { evaluateThresholds } from "./thresholds.js";
-describe("thresholds", () => {
-    describe("evaluateThresholds", () => {
-        it("fires ThresholdEvent at 50% crossing", () => {
-            const result = evaluateThresholds({
-                prevUsd: 0.4,
-                nextUsd: 0.55,
-                capUsd: 1.0,
-                firedThisMonth: [],
-            });
-            expect(result.events).toHaveLength(1);
-            expect(result.events[0].level).toBe(50);
-            expect(result.nextFired).toContain(50);
-        });
-        it("does not re-fire 50% if already in firedThisMonth", () => {
-            const result = evaluateThresholds({
-                prevUsd: 0.55,
-                nextUsd: 0.6,
-                capUsd: 1.0,
-                firedThisMonth: [50],
-            });
-            expect(result.events).toHaveLength(0);
-        });
-        it("fires 80% and 100% in sequence", () => {
-            const r80 = evaluateThresholds({
-                prevUsd: 0.7,
-                nextUsd: 0.85,
-                capUsd: 1.0,
-                firedThisMonth: [50],
-            });
-            expect(r80.events).toHaveLength(1);
-            expect(r80.events[0].level).toBe(80);
-            const r100 = evaluateThresholds({
-                prevUsd: 0.85,
-                nextUsd: 1.05,
-                capUsd: 1.0,
-                firedThisMonth: r80.nextFired,
-            });
-            expect(r100.events).toHaveLength(1);
-            expect(r100.events[0].level).toBe(100);
-        });
-        it("fires multiple thresholds in one jump", () => {
-            const result = evaluateThresholds({
-                prevUsd: 0.0,
-                nextUsd: 1.05,
-                capUsd: 1.0,
-                firedThisMonth: [],
-            });
-            expect(result.events).toHaveLength(3);
-            expect(result.events.map((e) => e.level)).toEqual([50, 80, 100]);
-        });
-        it("resets on month rollover (empty firedThisMonth)", () => {
-            // After month rollover, firedThisMonth is empty again
-            const result = evaluateThresholds({
-                prevUsd: 0.0,
-                nextUsd: 0.55,
-                capUsd: 1.0,
-                firedThisMonth: [], // reset after rollover
-            });
-            expect(result.events).toHaveLength(1);
-            expect(result.events[0].level).toBe(50);
-        });
-        it("includes correct current_pct and cap_usd in event", () => {
-            const result = evaluateThresholds({
-                prevUsd: 0.0,
-                nextUsd: 0.55,
-                capUsd: 1.0,
-                firedThisMonth: [],
-            });
-            expect(result.events[0].current_pct).toBeCloseTo(55, 0);
-            expect(result.events[0].cap_usd).toBe(1.0);
-            expect(result.events[0].current_usd).toBe(0.55);
-        });
-    });
-});
-//# sourceMappingURL=thresholds.test.js.map

package/dist/src/utils/__tests__/auto-council-settings.test.d.ts

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

package/dist/src/utils/__tests__/auto-council-settings.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeAutoCouncilConfidence, normalizeAutoCouncilMinRoles } from "../settings.js";
-describe("normalizeAutoCouncilConfidence", () => {
-    it("defaults to 0.85 when undefined / wrong type", () => {
-        expect(normalizeAutoCouncilConfidence(undefined)).toBe(0.85);
-        expect(normalizeAutoCouncilConfidence(null)).toBe(0.85);
-        expect(normalizeAutoCouncilConfidence("0.9")).toBe(0.85);
-        expect(normalizeAutoCouncilConfidence({})).toBe(0.85);
-    });
-    it("accepts values inside [0.5, 1.0]", () => {
-        expect(normalizeAutoCouncilConfidence(0.5)).toBe(0.5);
-        expect(normalizeAutoCouncilConfidence(0.7)).toBe(0.7);
-        expect(normalizeAutoCouncilConfidence(0.85)).toBe(0.85);
-        expect(normalizeAutoCouncilConfidence(1.0)).toBe(1.0);
-    });
-    it("clamps to default when out of range", () => {
-        expect(normalizeAutoCouncilConfidence(0.49)).toBe(0.85);
-        expect(normalizeAutoCouncilConfidence(0)).toBe(0.85);
-        expect(normalizeAutoCouncilConfidence(1.01)).toBe(0.85);
-        expect(normalizeAutoCouncilConfidence(-1)).toBe(0.85);
-    });
-});
-describe("normalizeAutoCouncilMinRoles", () => {
-    it("defaults to 2 when undefined / wrong type", () => {
-        expect(normalizeAutoCouncilMinRoles(undefined)).toBe(2);
-        expect(normalizeAutoCouncilMinRoles(null)).toBe(2);
-        expect(normalizeAutoCouncilMinRoles("2")).toBe(2);
-    });
-    it("accepts integers in [1, 4]", () => {
-        expect(normalizeAutoCouncilMinRoles(1)).toBe(1);
-        expect(normalizeAutoCouncilMinRoles(2)).toBe(2);
-        expect(normalizeAutoCouncilMinRoles(3)).toBe(3);
-        expect(normalizeAutoCouncilMinRoles(4)).toBe(4);
-    });
-    it("rejects non-integer / out-of-range", () => {
-        expect(normalizeAutoCouncilMinRoles(0)).toBe(2);
-        expect(normalizeAutoCouncilMinRoles(5)).toBe(2);
-        expect(normalizeAutoCouncilMinRoles(2.5)).toBe(2);
-    });
-});
-//# sourceMappingURL=auto-council-settings.test.js.map

package/dist/src/utils/__tests__/compaction-caps.test.d.ts

@@ -1,21 +0,0 @@
-/**
- * src/utils/__tests__/compaction-caps.test.ts
- *
- * G4 regression guard for the token-thrift compaction caps.
- *
- * The compaction caps themselves are wired correctly (cost-leak-b3/b4 specs
- * cover the algorithm; the *-tui specs cover the live wiring). The hole this
- * file closes is DRIFT: nothing pinned the PRODUCTION DEFAULT knob values, and
- * the fast cost-leak specs drive `compactSubAgentMessages` with HARDCODED
- * options (thresholdChars: 60_000, keepLastTurns: 1) that are decoupled from
- * the real getters. So a regression that widens a default (e.g. reverting the
- * Phase C5 40_000 back to 200_000, or fat-fingering a clamp range) would sail
- * past the entire fast suite and only be caught by the slow ~30-120s TUI specs.
- *
- * Part 1 pins each getter's documented contract (default / clamp / honor).
- * Part 2 feeds the REAL getter outputs into the compactor over a synthetic
- * load sized BETWEEN the default threshold and a plausible widened drift, so a
- * default-value regression fails behaviourally too — not just at the value
- * assertion.
- */
-export {};

package/dist/src/utils/__tests__/compaction-caps.test.js

@@ -1,187 +0,0 @@
-/**
- * src/utils/__tests__/compaction-caps.test.ts
- *
- * G4 regression guard for the token-thrift compaction caps.
- *
- * The compaction caps themselves are wired correctly (cost-leak-b3/b4 specs
- * cover the algorithm; the *-tui specs cover the live wiring). The hole this
- * file closes is DRIFT: nothing pinned the PRODUCTION DEFAULT knob values, and
- * the fast cost-leak specs drive `compactSubAgentMessages` with HARDCODED
- * options (thresholdChars: 60_000, keepLastTurns: 1) that are decoupled from
- * the real getters. So a regression that widens a default (e.g. reverting the
- * Phase C5 40_000 back to 200_000, or fat-fingering a clamp range) would sail
- * past the entire fast suite and only be caught by the slow ~30-120s TUI specs.
- *
- * Part 1 pins each getter's documented contract (default / clamp / honor).
- * Part 2 feeds the REAL getter outputs into the compactor over a synthetic
- * load sized BETWEEN the default threshold and a plausible widened drift, so a
- * default-value regression fails behaviourally too — not just at the value
- * assertion.
- */
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { compactSubAgentMessages, cumulativeMessageChars } from "../../orchestrator/subagent-compactor.js";
-import { getSubAgentBudgetChars, getSubAgentCompactKeepLast, getSubAgentCompactThresholdChars, getTopLevelCompactKeepLast, getTopLevelCompactThresholdChars, getTopLevelToolBudgetChars, loadUserSettings, } from "../settings.js";
-const ENV_KEYS = [
-    "MUONROI_SUB_AGENT_BUDGET_CHARS",
-    "MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS",
-    "MUONROI_SUBAGENT_COMPACT_KEEP_LAST",
-    "MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS",
-    "MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST",
-    "MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS",
-];
-const saved = {};
-beforeEach(() => {
-    for (const k of ENV_KEYS) {
-        saved[k] = process.env[k];
-        delete process.env[k];
-    }
-});
-afterEach(() => {
-    for (const k of ENV_KEYS) {
-        if (saved[k] === undefined)
-            delete process.env[k];
-        else
-            process.env[k] = saved[k];
-    }
-});
-describe("compaction cap getters — production contract (G4 drift guard)", () => {
-    describe("compact thresholds & keepLast (Phase C5 defaults — no user-settings layer)", () => {
-        it("return the documented defaults when env is unset", () => {
-            expect(getSubAgentCompactThresholdChars()).toBe(40_000);
-            expect(getSubAgentCompactKeepLast()).toBe(3);
-            expect(getTopLevelCompactThresholdChars()).toBe(100_000);
-            expect(getTopLevelCompactKeepLast()).toBe(5);
-        });
-        it("clamp out-of-range env back to the default", () => {
-            process.env.MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS = "999999999"; // > 500_000
-            expect(getSubAgentCompactThresholdChars()).toBe(40_000);
-            process.env.MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS = "1000"; // < 20_000
-            expect(getSubAgentCompactThresholdChars()).toBe(40_000);
-            process.env.MUONROI_SUBAGENT_COMPACT_KEEP_LAST = "0"; // < 1
-            expect(getSubAgentCompactKeepLast()).toBe(3);
-            process.env.MUONROI_SUBAGENT_COMPACT_KEEP_LAST = "99"; // > 20
-            expect(getSubAgentCompactKeepLast()).toBe(3);
-            process.env.MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS = "10000"; // < 50_000
-            expect(getTopLevelCompactThresholdChars()).toBe(100_000);
-            process.env.MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST = "99"; // > 30
-            expect(getTopLevelCompactKeepLast()).toBe(5);
-        });
-        it("honor valid in-range env overrides", () => {
-            process.env.MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS = "60000";
-            expect(getSubAgentCompactThresholdChars()).toBe(60_000);
-            process.env.MUONROI_SUBAGENT_COMPACT_KEEP_LAST = "5";
-            expect(getSubAgentCompactKeepLast()).toBe(5);
-            process.env.MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS = "250000";
-            expect(getTopLevelCompactThresholdChars()).toBe(250_000);
-            process.env.MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST = "8";
-            expect(getTopLevelCompactKeepLast()).toBe(8);
-        });
-    });
-    describe("budget getters (env override → user-settings → default)", () => {
-        it("getSubAgentBudgetChars: default 240_000 when env unset and no user override", () => {
-            // Deterministic on a clean checkout / CI (no user-settings.json). When a
-            // dev machine HAS an explicit override the getter must honor it instead —
-            // the default-drift case is what CI guards.
-            const override = loadUserSettings().subAgentBudgetChars;
-            if (typeof override === "number" && override >= 20_000 && override <= 5_000_000) {
-                expect(getSubAgentBudgetChars()).toBe(Math.floor(override));
-            }
-            else {
-                expect(getSubAgentBudgetChars()).toBe(240_000);
-            }
-        });
-        it("getTopLevelToolBudgetChars: default 400_000 when env unset and no user override", () => {
-            const override = loadUserSettings().topLevelToolBudgetChars;
-            if (typeof override === "number" && override >= 50_000 && override <= 10_000_000) {
-                expect(getTopLevelToolBudgetChars()).toBe(Math.floor(override));
-            }
-            else {
-                expect(getTopLevelToolBudgetChars()).toBe(400_000);
-            }
-        });
-        it("honor valid in-range env overrides (env short-circuits user-settings)", () => {
-            process.env.MUONROI_SUB_AGENT_BUDGET_CHARS = "300000";
-            expect(getSubAgentBudgetChars()).toBe(300_000);
-            process.env.MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS = "800000";
-            expect(getTopLevelToolBudgetChars()).toBe(800_000);
-        });
-        it("reject out-of-range env (result stays within the documented range)", () => {
-            process.env.MUONROI_SUB_AGENT_BUDGET_CHARS = "999999999"; // > 5_000_000
-            const sub = getSubAgentBudgetChars();
-            expect(sub).not.toBe(999_999_999);
-            expect(sub).toBeGreaterThanOrEqual(20_000);
-            expect(sub).toBeLessThanOrEqual(5_000_000);
-            process.env.MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS = "1000"; // < 50_000
-            const top = getTopLevelToolBudgetChars();
-            expect(top).not.toBe(1000);
-            expect(top).toBeGreaterThanOrEqual(50_000);
-            expect(top).toBeLessThanOrEqual(10_000_000);
-        });
-    });
-});
-/**
- * Build N tool turns (assistant tool-call + tool result), each result
- * `resultChars` long, using a tool name that is NOT high-value (so the
- * compactor is allowed to elide it). Mirrors the cost-leak-b3 message shape.
- */
-function buildToolTurns(n, resultChars) {
-    const msgs = [
-        { role: "system", content: "You are the Explore sub-agent." },
-        { role: "user", content: "trace auth wiring" },
-    ];
-    for (let i = 0; i < n; i++) {
-        const id = `c${i}`;
-        msgs.push({
-            role: "assistant",
-            content: [{ type: "tool-call", toolCallId: id, toolName: "fake_read", input: { path: `/tmp/${id}.txt` } }],
-        });
-        msgs.push({
-            role: "tool",
-            content: [
-                {
-                    type: "tool-result",
-                    toolCallId: id,
-                    toolName: "fake_read",
-                    output: { type: "text", value: "x".repeat(resultChars) },
-                },
-            ],
-        });
-    }
-    return msgs;
-}
-describe("compaction fires with the REAL default getter values (G4 behavioural guard)", () => {
-    // Load sized BETWEEN the default thresholds (40K sub / 100K top) and a
-    // plausible widened drift (200K). So: with the real defaults it compacts;
-    // if a default were reverted to 200_000 the load would fall below threshold
-    // and these assertions would fail — catching drift behaviourally.
-    it("sub-agent: default threshold (40K) elides older tool results on a ~120K load", () => {
-        const messages = buildToolTurns(6, 20_000); // ~120K cumulative, 6 tool turns
-        const cumulative = cumulativeMessageChars(messages);
-        expect(cumulative).toBeGreaterThan(40_000);
-        expect(cumulative).toBeLessThan(200_000);
-        const compacted = compactSubAgentMessages(messages, {
-            thresholdChars: getSubAgentCompactThresholdChars(),
-            keepLastTurns: getSubAgentCompactKeepLast(),
-        });
-        expect(compacted).not.toBe(messages); // identity differs → compaction happened
-        const before = JSON.stringify(messages).length;
-        const after = JSON.stringify(compacted).length;
-        expect(after).toBeLessThan(before);
-        expect(JSON.stringify(compacted)).toContain("elided by sub-agent compactor");
-    });
-    it("top-level: default threshold (100K) elides older tool results on a ~160K load", () => {
-        const messages = buildToolTurns(8, 20_000); // ~160K cumulative, 8 tool turns
-        const cumulative = cumulativeMessageChars(messages);
-        expect(cumulative).toBeGreaterThan(100_000);
-        expect(cumulative).toBeLessThan(200_000);
-        const compacted = compactSubAgentMessages(messages, {
-            thresholdChars: getTopLevelCompactThresholdChars(),
-            keepLastTurns: getTopLevelCompactKeepLast(),
-            label: "top-level",
-        });
-        expect(compacted).not.toBe(messages);
-        expect(JSON.stringify(compacted).length).toBeLessThan(JSON.stringify(messages).length);
-        expect(JSON.stringify(compacted)).toContain("elided by top-level compactor");
-    });
-});
-//# sourceMappingURL=compaction-caps.test.js.map

package/dist/src/utils/__tests__/ee-logger.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * Unit tests for src/utils/ee-logger.ts.
- *
- * The logger is the foundation of Phase 21 observability — every silent EE
- * catch site routes through it. These tests pin down the four guarantees:
- *   1. Warn line has stable `[ee.<source>.<kind>]` prefix shape.
- *   2. `ee-timeout` / `ee-error` events fire when the agent runtime is wired.
- *   3. No-op event path when the runtime is absent (composer-only sessions).
- *   4. Never throws on `null` / `undefined` / non-Error `err` arguments.
- */
-export {};

package/dist/src/utils/__tests__/ee-logger.test.js

@@ -1,165 +0,0 @@
-/**
- * Unit tests for src/utils/ee-logger.ts.
- *
- * The logger is the foundation of Phase 21 observability — every silent EE
- * catch site routes through it. These tests pin down the four guarantees:
- *   1. Warn line has stable `[ee.<source>.<kind>]` prefix shape.
- *   2. `ee-timeout` / `ee-error` events fire when the agent runtime is wired.
- *   3. No-op event path when the runtime is absent (composer-only sessions).
- *   4. Never throws on `null` / `undefined` / non-Error `err` arguments.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { classifyEeError, logEeFailure, withEeTimeout } from "../ee-logger.js";
-function installRuntime() {
-    const stub = { emitEvent: vi.fn() };
-    globalThis.__muonroiAgentRuntime = stub;
-    return stub;
-}
-function removeRuntime() {
-    delete globalThis.__muonroiAgentRuntime;
-}
-describe("ee-logger", () => {
-    let warnSpy;
-    beforeEach(() => {
-        warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-        removeRuntime();
-    });
-    afterEach(() => {
-        warnSpy.mockRestore();
-        removeRuntime();
-    });
-    describe("logEeFailure", () => {
-        it("emits warn with [ee.<source>.<kind>] prefix and structured error", () => {
-            const err = new Error("connection refused");
-            logEeFailure("bridge.classifyViaBrain", "error", err, { elapsedMs: 12 });
-            expect(warnSpy).toHaveBeenCalledTimes(1);
-            const args = warnSpy.mock.calls[0];
-            expect(args[0]).toBe("[ee.bridge.classifyViaBrain.error]");
-            expect(args[1]).toEqual({ name: "Error", message: "connection refused" });
-            expect(args[2]).toEqual({ elapsedMs: 12 });
-        });
-        it("emits ee-timeout event when runtime is present and kind=timeout", () => {
-            const stub = installRuntime();
-            const err = Object.assign(new Error("aborted"), { name: "TimeoutError" });
-            logEeFailure("bridge.searchByText", "timeout", err, {
-                elapsedMs: 1502,
-                budgetMs: 1500,
-            });
-            expect(stub.emitEvent).toHaveBeenCalledTimes(1);
-            const ev = stub.emitEvent.mock.calls[0][0];
-            expect(ev.t).toBe("event");
-            expect(ev.kind).toBe("ee-timeout");
-            expect(ev.source).toBe("bridge.searchByText");
-            expect(ev.elapsedMs).toBe(1502);
-            expect(ev.budgetMs).toBe(1500);
-            expect(typeof ev.ts).toBe("number");
-        });
-        it("emits ee-error event with name/message when runtime is present and kind=error", () => {
-            const stub = installRuntime();
-            const err = new TypeError("not a function");
-            logEeFailure("client.posttool", "error", err);
-            expect(stub.emitEvent).toHaveBeenCalledTimes(1);
-            const ev = stub.emitEvent.mock.calls[0][0];
-            expect(ev.kind).toBe("ee-error");
-            expect(ev.source).toBe("client.posttool");
-            expect(ev.name).toBe("TypeError");
-            expect(ev.message).toBe("not a function");
-            expect(typeof ev.ts).toBe("number");
-        });
-        it("is a no-op on the event path when runtime is absent", () => {
-            // No installRuntime() — runtime missing.
-            expect(() => logEeFailure("pil.layer4.routeTask", "error", new Error("x"))).not.toThrow();
-            expect(warnSpy).toHaveBeenCalledTimes(1);
-            // No runtime to assert on — just confirm no throw and warn still fires.
-        });
-        it("never throws on null err", () => {
-            installRuntime();
-            expect(() => logEeFailure("pil.pipeline.logInteraction", "error", null)).not.toThrow();
-            expect(warnSpy).toHaveBeenCalledOnce();
-            const args = warnSpy.mock.calls[0];
-            expect(args[1].name).toBe("Null");
-        });
-        it("never throws on undefined err", () => {
-            installRuntime();
-            expect(() => logEeFailure("phase-outcome.recordCouncilOutcome", "error", undefined)).not.toThrow();
-            const args = warnSpy.mock.calls[0];
-            expect(args[1].name).toBe("Undefined");
-        });
-        it("never throws on string err and uses the string as message", () => {
-            installRuntime();
-            expect(() => logEeFailure("client.feedback", "error", "boom")).not.toThrow();
-            const args = warnSpy.mock.calls[0];
-            expect(args[1]).toEqual({ name: "String", message: "boom" });
-        });
-        it("never throws on object-with-name err", () => {
-            installRuntime();
-            const errLike = { name: "AbortError", message: "request aborted" };
-            expect(() => logEeFailure("bridge.routeTask", "timeout", errLike)).not.toThrow();
-            const args = warnSpy.mock.calls[0];
-            expect(args[1]).toEqual({ name: "AbortError", message: "request aborted" });
-        });
-        it("does not propagate emitEvent exceptions", () => {
-            const stub = {
-                emitEvent: vi.fn(() => {
-                    throw new Error("subscriber blew up");
-                }),
-            };
-            globalThis.__muonroiAgentRuntime = stub;
-            expect(() => logEeFailure("client.touch", "error", new Error("x"))).not.toThrow();
-            expect(stub.emitEvent).toHaveBeenCalledTimes(1);
-        });
-        it("survives a runtime where emitEvent is not a function", () => {
-            globalThis.__muonroiAgentRuntime = { emitEvent: "nope" };
-            expect(() => logEeFailure("bridge.routeModel", "error", new Error("x"))).not.toThrow();
-        });
-    });
-    describe("classifyEeError", () => {
-        it("classifies TimeoutError as timeout", () => {
-            const err = Object.assign(new Error("x"), { name: "TimeoutError" });
-            expect(classifyEeError(err)).toBe("timeout");
-        });
-        it("classifies AbortError as timeout", () => {
-            const err = Object.assign(new Error("x"), { name: "AbortError" });
-            expect(classifyEeError(err)).toBe("timeout");
-        });
-        it("classifies generic Error as error", () => {
-            expect(classifyEeError(new Error("boom"))).toBe("error");
-        });
-        it("classifies TypeError as error", () => {
-            expect(classifyEeError(new TypeError("boom"))).toBe("error");
-        });
-        it("classifies null / undefined / string as error", () => {
-            expect(classifyEeError(null)).toBe("error");
-            expect(classifyEeError(undefined)).toBe("error");
-            expect(classifyEeError("boom")).toBe("error");
-        });
-        it("classifies plain object with TimeoutError name as timeout", () => {
-            expect(classifyEeError({ name: "TimeoutError" })).toBe("timeout");
-        });
-    });
-    describe("withEeTimeout (Phase 21.5)", () => {
-        it("resolves through when the inner promise settles in time", async () => {
-            const v = await withEeTimeout(Promise.resolve(42), 50);
-            expect(v).toBe(42);
-        });
-        it("rejects with TimeoutError when the inner promise takes too long", async () => {
-            const slow = new Promise((resolve) => setTimeout(() => resolve(7), 100));
-            await expect(withEeTimeout(slow, 20)).rejects.toMatchObject({ name: "TimeoutError" });
-        });
-        it("forwards inner rejection unchanged when it beats the timeout", async () => {
-            const err = new Error("inner boom");
-            await expect(withEeTimeout(Promise.reject(err), 50)).rejects.toBe(err);
-        });
-        it("rejected error classifies as timeout via classifyEeError", async () => {
-            const slow = new Promise((resolve) => setTimeout(() => resolve(0), 100));
-            try {
-                await withEeTimeout(slow, 10);
-                throw new Error("should not reach");
-            }
-            catch (e) {
-                expect(classifyEeError(e)).toBe("timeout");
-            }
-        });
-    });
-});
-//# sourceMappingURL=ee-logger.test.js.map

package/dist/src/utils/__tests__/file-lock.test.d.ts

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

package/dist/src/utils/__tests__/file-lock.test.js

@@ -1,66 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { withFileLock } from "../file-lock.js";
-describe("withFileLock", () => {
-    let tmpFile;
-    beforeEach(async () => {
-        const dir = path.join(os.tmpdir(), `lock-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(dir, { recursive: true });
-        tmpFile = path.join(dir, "target.json");
-    });
-    it("runs the callback and returns its value", async () => {
-        const result = await withFileLock(tmpFile, async () => 42);
-        expect(result).toBe(42);
-    });
-    it("removes lockfile after callback completes", async () => {
-        await withFileLock(tmpFile, async () => { });
-        await expect(fs.stat(`${tmpFile}.lock`)).rejects.toThrow();
-    });
-    it("removes lockfile even if callback throws", async () => {
-        await expect(withFileLock(tmpFile, async () => {
-            throw new Error("boom");
-        })).rejects.toThrow("boom");
-        await expect(fs.stat(`${tmpFile}.lock`)).rejects.toThrow();
-    });
-    it("serializes concurrent callers on same path", async () => {
-        const order = [];
-        const p1 = withFileLock(tmpFile, async () => {
-            order.push(1);
-            await new Promise((r) => setTimeout(r, 30));
-            order.push(2);
-        });
-        const p2 = withFileLock(tmpFile, async () => {
-            order.push(3);
-            order.push(4);
-        });
-        await Promise.all([p1, p2]);
-        expect(order).toEqual([1, 2, 3, 4]);
-    });
-    it("different paths do NOT block each other", async () => {
-        const other = `${tmpFile}.other`;
-        const start = Date.now();
-        await Promise.all([
-            withFileLock(tmpFile, async () => {
-                await new Promise((r) => setTimeout(r, 50));
-            }),
-            withFileLock(other, async () => {
-                await new Promise((r) => setTimeout(r, 50));
-            }),
-        ]);
-        const elapsed = Date.now() - start;
-        expect(elapsed).toBeLessThan(90);
-    });
-    it("respects retry timeout", async () => {
-        await fs.writeFile(`${tmpFile}.lock`, "manual");
-        let acquired = false;
-        const release = setTimeout(() => fs.unlink(`${tmpFile}.lock`).catch(() => { }), 50);
-        await withFileLock(tmpFile, async () => {
-            acquired = true;
-        });
-        clearTimeout(release);
-        expect(acquired).toBe(true);
-    });
-});
-//# sourceMappingURL=file-lock.test.js.map

package/dist/src/utils/__tests__/footprint-gitignore.test.d.ts

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