muonroi-cli 1.8.0 → 1.8.3

package/dist/src/orchestrator/__tests__/retry-classifier.test.js

@@ -1,112 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { classifyStreamError } from "../retry-classifier.js";
-import { STALL_ABORT_REASON } from "../stall-watchdog.js";
-describe("classifyStreamError", () => {
-    it("classifies ECONNREFUSED as transient", () => {
-        const err = new Error("connect ECONNREFUSED 127.0.0.1:443");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies ETIMEDOUT as transient", () => {
-        const err = new Error("request failed: ETIMEDOUT");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies 'fetch failed' TypeError as transient", () => {
-        const err = new TypeError("fetch failed");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 502 as transient", () => {
-        const err = Object.assign(new Error("Bad Gateway"), { statusCode: 502 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 503 as transient", () => {
-        const err = Object.assign(new Error("Service Unavailable"), { statusCode: 503 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 504 as transient", () => {
-        const err = Object.assign(new Error("Gateway Timeout"), { statusCode: 504 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 429 as transient", () => {
-        const err = Object.assign(new Error("Too Many Requests"), { statusCode: 429 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 401 as NOT transient", () => {
-        const err = Object.assign(new Error("Unauthorized"), { statusCode: 401 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies HTTP 400 as NOT transient", () => {
-        const err = Object.assign(new Error("Bad Request"), { statusCode: 400 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies HTTP 403 as NOT transient", () => {
-        const err = Object.assign(new Error("Forbidden"), { statusCode: 403 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies HTTP 422 as NOT transient", () => {
-        const err = Object.assign(new Error("Unprocessable Entity"), { statusCode: 422 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies AbortError (user cancel) as NOT transient", () => {
-        const err = new DOMException("Aborted", "AbortError");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies a provider-stall watchdog abort as NOT transient (no retry-storm)", () => {
-        // The stall watchdog aborts with DOMException(STALL_ABORT_REASON, "TimeoutError").
-        // It must NOT be retried — a stalled provider just stalls again, burning
-        // another full timeout of silence. Distinct from a generic AbortSignal.timeout().
-        const err = new DOMException(STALL_ABORT_REASON, "TimeoutError");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-        expect(result.reason).toBe("provider-stall");
-    });
-    it("classifies TimeoutError (AbortSignal.timeout) as transient", () => {
-        const err = new DOMException("signal timed out", "TimeoutError");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("finds transient code in nested cause chain", () => {
-        const inner = new Error("connect ECONNRESET");
-        const outer = Object.assign(new Error("Request failed"), { cause: inner });
-        const result = classifyStreamError(outer);
-        expect(result.transient).toBe(true);
-        expect(result.reason).toMatch(/^cause:/);
-    });
-    it("classifies 'socket hang up' as transient", () => {
-        const err = new Error("socket hang up");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies 'Unable to connect' as transient", () => {
-        const err = new Error("Cannot connect to API: Unable to connect. Is the computer able to access the url?");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 500 as transient", () => {
-        const err = Object.assign(new Error("Internal Server Error"), { statusCode: 500 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 408 as transient", () => {
-        const err = Object.assign(new Error("Request Timeout"), { statusCode: 408 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies unknown error as NOT transient", () => {
-        const err = new Error("some weird unexpected error");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-});
-//# sourceMappingURL=retry-classifier.test.js.map

package/dist/src/orchestrator/__tests__/retry-stream.test.d.ts

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

package/dist/src/orchestrator/__tests__/retry-stream.test.js

@@ -1,151 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { withStreamRetry } from "../retry-stream.js";
-// Fast no-op delay for all tests
-const fastDelay = () => Promise.resolve();
-function makeTransientError(msg = "fetch failed", statusCode) {
-    return Object.assign(new TypeError(msg), statusCode != null ? { statusCode } : {});
-}
-function makeNonTransientError(statusCode = 401) {
-    return Object.assign(new Error("Unauthorized"), { statusCode });
-}
-describe("withStreamRetry", () => {
-    it("1. succeeds on first attempt — factory called once", async () => {
-        const factory = vi.fn().mockResolvedValueOnce("ok");
-        const result = await withStreamRetry(factory, { delay: fastDelay });
-        expect(result).toBe("ok");
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-    it("2. transient on attempt 1, success on 2 — factory called twice, onRetry fired once", async () => {
-        const retries = [];
-        const factory = vi.fn().mockRejectedValueOnce(makeTransientError()).mockResolvedValueOnce("second");
-        const result = await withStreamRetry(factory, {
-            delay: fastDelay,
-            onRetry: (info) => retries.push(info),
-        });
-        expect(result).toBe("second");
-        expect(factory).toHaveBeenCalledTimes(2);
-        expect(retries).toHaveLength(1);
-        expect(retries[0].attempt).toBe(1);
-        expect(retries[0].maxAttempts).toBe(3);
-    });
-    it("3. transient on 1+2, success on 3 — onRetry fired twice", async () => {
-        const retries = [];
-        const factory = vi
-            .fn()
-            .mockRejectedValueOnce(makeTransientError())
-            .mockRejectedValueOnce(makeTransientError())
-            .mockResolvedValueOnce("third");
-        const result = await withStreamRetry(factory, {
-            delay: fastDelay,
-            onRetry: (info) => retries.push(info),
-        });
-        expect(result).toBe("third");
-        expect(factory).toHaveBeenCalledTimes(3);
-        expect(retries).toHaveLength(2);
-        expect(retries[0].attempt).toBe(1);
-        expect(retries[1].attempt).toBe(2);
-    });
-    it("4. transient on all 3 — final error thrown after maxAttempts", async () => {
-        const err = makeTransientError("ECONNREFUSED");
-        const factory = vi.fn().mockRejectedValue(err);
-        await expect(withStreamRetry(factory, { delay: fastDelay, onRetry: () => { } })).rejects.toBe(err);
-        expect(factory).toHaveBeenCalledTimes(3);
-    });
-    it("5. non-transient error — no retry, immediate throw", async () => {
-        const err = makeNonTransientError(401);
-        const factory = vi.fn().mockRejectedValue(err);
-        await expect(withStreamRetry(factory, { delay: fastDelay })).rejects.toBe(err);
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-    it("6. signal.aborted before first attempt — no factory call, AbortError thrown", async () => {
-        const controller = new AbortController();
-        controller.abort();
-        const factory = vi.fn().mockResolvedValue("x");
-        await expect(withStreamRetry(factory, { delay: fastDelay, signal: controller.signal })).rejects.toMatchObject({
-            name: "AbortError",
-        });
-        expect(factory).toHaveBeenCalledTimes(0);
-    });
-    it("7. signal.aborted between attempts — retry loop bails", async () => {
-        const controller = new AbortController();
-        let callCount = 0;
-        const factory = vi.fn().mockImplementation(async () => {
-            callCount++;
-            if (callCount === 1) {
-                // Abort during the retry
-                controller.abort();
-                throw makeTransientError();
-            }
-            return "should not reach";
-        });
-        await expect(withStreamRetry(factory, {
-            delay: () => Promise.resolve(), // fast delay
-            signal: controller.signal,
-            onRetry: () => { },
-        })).rejects.toMatchObject({ name: "AbortError" });
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-    it("8. Retry-After header (seconds string) — uses that delay for THIS attempt", async () => {
-        const delays = [];
-        const retryAfterErr = Object.assign(new Error("Rate limited"), {
-            statusCode: 429,
-            retryAfter: "5", // 5 seconds = 5000 ms
-        });
-        const factory = vi.fn().mockRejectedValueOnce(retryAfterErr).mockResolvedValueOnce("ok");
-        const retries = [];
-        await withStreamRetry(factory, {
-            delay: (ms) => {
-                delays.push(ms);
-                return Promise.resolve();
-            },
-            onRetry: (info) => retries.push(info),
-        });
-        expect(retries[0].nextDelayMs).toBe(5000);
-        expect(delays[0]).toBe(5000);
-    });
-    it("9. jitter stays within ±jitter*delay range", async () => {
-        // Run 30 times and check every delay is within ±25% of 500ms base
-        const baseDelayMs = 500;
-        const jitter = 0.25;
-        const spread = baseDelayMs * jitter;
-        const min = baseDelayMs - spread;
-        const max = baseDelayMs + spread;
-        for (let i = 0; i < 30; i++) {
-            const delays = [];
-            const factory = vi.fn().mockRejectedValueOnce(makeTransientError()).mockResolvedValueOnce("ok");
-            await withStreamRetry(factory, {
-                maxAttempts: 2,
-                baseDelayMs,
-                jitter,
-                delay: (ms) => {
-                    delays.push(ms);
-                    return Promise.resolve();
-                },
-            });
-            expect(delays[0]).toBeGreaterThanOrEqual(min);
-            expect(delays[0]).toBeLessThanOrEqual(max);
-        }
-    });
-    it("10. maxDelayMs cap respected", async () => {
-        const delays = [];
-        const factory = vi
-            .fn()
-            .mockRejectedValueOnce(makeTransientError())
-            .mockRejectedValueOnce(makeTransientError())
-            .mockResolvedValueOnce("ok");
-        await withStreamRetry(factory, {
-            maxAttempts: 3,
-            baseDelayMs: 500,
-            maxDelayMs: 1000, // lower cap than default 8000
-            jitter: 0, // no jitter so we get exact values
-            delay: (ms) => {
-                delays.push(ms);
-                return Promise.resolve();
-            },
-        });
-        // attempt 1: 500, attempt 2: 2000 → capped to 1000
-        expect(delays[0]).toBe(500);
-        expect(delays[1]).toBe(1000);
-    });
-});
-//# sourceMappingURL=retry-stream.test.js.map

package/dist/src/orchestrator/__tests__/route-feedback.test.d.ts

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

package/dist/src/orchestrator/__tests__/route-feedback.test.js

@@ -1,47 +0,0 @@
-// Test stubs for ROUTE-11 routeFeedback wiring in orchestrator
-import { beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("../../ee/bridge.js", () => ({
-    routeFeedback: vi.fn().mockResolvedValue(true),
-    routeModel: vi.fn().mockResolvedValue(null),
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    resetBridge: vi.fn(),
-}));
-vi.mock("../../pil/task-tier-map.js", () => ({
-    taskTypeToTier: vi.fn().mockReturnValue("balanced"),
-}));
-describe("routeFeedback wiring", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should import routeFeedback from bridge", async () => {
-        const bridge = await import("../../ee/bridge.js");
-        expect(bridge.routeFeedback).toBeDefined();
-    });
-    it("should import taskTypeToTier from task-tier-map", async () => {
-        const tierMap = await import("../../pil/task-tier-map.js");
-        expect(tierMap.taskTypeToTier).toBeDefined();
-    });
-    it("routeFeedback signature accepts required params", async () => {
-        const { routeFeedback } = await import("../../ee/bridge.js");
-        // Verify the function can be called with correct signature
-        await routeFeedback("hash123", "balanced", "claude-3", "success", 0, 1500);
-        expect(routeFeedback).toHaveBeenCalledWith("hash123", "balanced", "claude-3", "success", 0, 1500);
-    });
-    it("taskTypeToTier maps correctly for routeFeedback tier param", async () => {
-        const { taskTypeToTier } = await import("../../pil/task-tier-map.js");
-        expect(taskTypeToTier("debug")).toBe("balanced");
-    });
-    it("routeFeedback returns true when bridge is available", async () => {
-        const { routeFeedback } = await import("../../ee/bridge.js");
-        const result = await routeFeedback("hash456", "premium", "claude-opus", "fail", 0, 3000);
-        expect(result).toBe(true);
-    });
-    it("routeFeedback is called with 'cancelled' outcome for cancelled turns", async () => {
-        const { routeFeedback } = await import("../../ee/bridge.js");
-        await routeFeedback("hash789", "fast", "claude-haiku", "cancelled", 0, 500);
-        expect(routeFeedback).toHaveBeenCalledWith("hash789", "fast", "claude-haiku", "cancelled", 0, 500);
-    });
-});
-//# sourceMappingURL=route-feedback.test.js.map

package/dist/src/orchestrator/__tests__/stream-runner.test.d.ts

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

package/dist/src/orchestrator/__tests__/stream-runner.test.js

@@ -1,202 +0,0 @@
-// Phase 12.3-03 — StreamRunner unit tests.
-//
-// Smoke-only: setup short-circuit paths (unknown agent, computer-on-textonly
-// runtime), DI surface invariants. Stream integration is covered by
-// tests/harness/cost-leak-{f1,g1,b3,b4,c3}.spec.ts — those exercise real
-// streamText with MockLanguageModelV3.
-import { beforeAll, describe, expect, it } from "vitest";
-import { getTestModelForProvider, getTestModels, getTestProviders } from "../../__test-helpers__/catalog-fixtures.js";
-import { loadCatalog } from "../../models/registry.js";
-import { computePromptCacheKey } from "../../providers/runtime.js";
-import { StreamRunner } from "../stream-runner.js";
-beforeAll(async () => {
-    await loadCatalog();
-});
-function makeBashStub() {
-    return {
-        getCwd: () => process.cwd(),
-        getSandboxMode: () => "off",
-        getSandboxSettings: () => ({}),
-    };
-}
-function makeDeps(overrides = {}) {
-    const testModels = getTestModels();
-    const testProviders = getTestProviders();
-    return {
-        getProvider: () => (() => null),
-        resolveModelForTask: () => testModels.fast,
-        getModelId: () => testModels.fast,
-        getProviderId: () => testProviders.default,
-        getBash: () => makeBashStub(),
-        getMaxToolRounds: () => 50,
-        getMaxTokens: () => 8192,
-        isBatchApiEnabled: () => false,
-        getCrossTurnDedup: () => null,
-        getReadBudget: () => null,
-        recordUsage: () => { },
-        setCurrentCallId: () => { },
-        setLastProviderOptionsShape: () => { },
-        getSessionId: () => undefined,
-        runTaskRequestBatch: async () => ({
-            success: false,
-            output: "batch path not exercised in this test",
-        }),
-        ...overrides,
-    };
-}
-describe("StreamRunner — setup short-circuit paths", () => {
-    it("returns unknown-agent short-circuit when agent kind is not recognised", async () => {
-        const runner = new StreamRunner(makeDeps());
-        const request = {
-            agent: "definitely-not-a-real-agent",
-            description: "test",
-            prompt: "noop",
-        };
-        const outcome = await runner.setup(request);
-        expect(outcome.kind).toBe("short-circuit");
-        if (outcome.kind === "short-circuit") {
-            expect(outcome.result.success).toBe(false);
-            expect(outcome.result.output).toContain(`Unknown sub-agent "definitely-not-a-real-agent"`);
-            expect(outcome.result.task?.agent).toBe("definitely-not-a-real-agent");
-        }
-    });
-    it("returns the same ToolResult shape that the in-line orchestrator did (parity check)", async () => {
-        // The pre-12.3 orchestrator returned { success: false, output: <msg>,
-        // task: { agent, description, summary: <msg> } } for unknown agents. Pin
-        // that shape so a future refactor that drops `task.summary` is caught.
-        const runner = new StreamRunner(makeDeps());
-        const outcome = await runner.setup({ agent: "??", description: "d", prompt: "p" });
-        expect(outcome.kind).toBe("short-circuit");
-        if (outcome.kind === "short-circuit") {
-            expect(outcome.result.task?.description).toBe("d");
-            expect(outcome.result.task?.summary).toEqual(outcome.result.output);
-        }
-    });
-});
-describe("StreamRunner — cheap-model steering on sub-agent system prompt", () => {
-    // The sub-agent prompt must carry the SAME front-loaded steering stack as the
-    // top-level turn for fast-tier models (regression: previously only the
-    // playbook was injected, leaving the sub-agent without the anti-ramble
-    // workbook or the shell directive). Final prompt order: [ENV] → [CRITICAL
-    // playbook] → [CONVERGENCE workbook] → base.
-    //
-    // `explore` is used because its childMode is "ask" (no MCP load) so setup()
-    // completes synchronously without spawning anything.
-    it("front-loads [ENV] → [CRITICAL] → [CONVERGENCE] for a fast-tier explore sub-agent", async () => {
-        const runner = new StreamRunner(makeDeps());
-        const outcome = await runner.setup({ agent: "explore", description: "scan", prompt: "find auth wiring" });
-        expect(outcome.kind).toBe("prepared");
-        if (outcome.kind !== "prepared")
-            return;
-        const sys = outcome.prepared.childSystem;
-        const iEnv = sys.indexOf("[ENV]");
-        const iCritical = sys.indexOf("[CRITICAL TOOL-USE RULES");
-        const iConvergence = sys.indexOf("[CONVERGENCE");
-        expect(sys.startsWith("[ENV]")).toBe(true);
-        expect(iEnv).toBeGreaterThanOrEqual(0);
-        expect(iCritical).toBeGreaterThan(iEnv);
-        expect(iConvergence).toBeGreaterThan(iCritical);
-        // explore → analyze workbook addendum.
-        expect(sys).toMatch(/do not read the whole codebase/i);
-    });
-});
-describe("StreamRunner — F1 promptCacheKey parity on the sub-agent path", () => {
-    // The top-level turn derives a stable openai.promptCacheKey per turn via
-    // buildTurnProviderOptions({ sessionId }) so every tool round in a session
-    // routes to the same cache node (message-processor.ts). The sub-agent path
-    // previously used only resolve-time childRuntime.providerOptions, which has
-    // NO promptCacheKey — so every explore/verify OpenAI call auto-hashed its
-    // prompt and fragmented the cache, re-billing the unchanging prefix. setup()
-    // must now thread the session id so sub-agents get the SAME stable key.
-    it("threads sessionId → openai.promptCacheKey onto the sub-agent providerOptions", async () => {
-        const sessionId = "sess-fixed-for-f1-parity";
-        const openaiModel = getTestModelForProvider("openai", "fast");
-        const runner = new StreamRunner(makeDeps({
-            resolveModelForTask: () => openaiModel,
-            getSessionId: () => sessionId,
-        }));
-        const outcome = await runner.setup({ agent: "explore", description: "scan", prompt: "find auth wiring" });
-        expect(outcome.kind).toBe("prepared");
-        if (outcome.kind !== "prepared")
-            return;
-        const opts = outcome.prepared.childProviderOptions;
-        expect(opts?.openai?.promptCacheKey).toBe(computePromptCacheKey(sessionId));
-    });
-    it("omits promptCacheKey when there is no session id (headless one-shot)", async () => {
-        const openaiModel = getTestModelForProvider("openai", "fast");
-        const runner = new StreamRunner(makeDeps({
-            resolveModelForTask: () => openaiModel,
-            getSessionId: () => undefined,
-        }));
-        const outcome = await runner.setup({ agent: "explore", description: "scan", prompt: "find auth wiring" });
-        expect(outcome.kind).toBe("prepared");
-        if (outcome.kind !== "prepared")
-            return;
-        const opts = outcome.prepared.childProviderOptions;
-        expect(opts?.openai?.promptCacheKey).toBeUndefined();
-    });
-});
-describe("StreamRunner — DI surface", () => {
-    it("constructs without invoking any dep callbacks", () => {
-        let touched = 0;
-        const trip = () => {
-            touched++;
-            throw new Error("touched");
-        };
-        // Every callback throws — instantiation must not call any of them.
-        const runner = new StreamRunner({
-            getProvider: trip,
-            resolveModelForTask: trip,
-            getModelId: trip,
-            getProviderId: trip,
-            getBash: trip,
-            getMaxToolRounds: trip,
-            getMaxTokens: trip,
-            isBatchApiEnabled: trip,
-            getCrossTurnDedup: trip,
-            getReadBudget: trip,
-            recordUsage: trip,
-            setCurrentCallId: trip,
-            setLastProviderOptionsShape: trip,
-            getSessionId: trip,
-            runTaskRequestBatch: trip,
-        });
-        expect(runner).toBeInstanceOf(StreamRunner);
-        expect(touched).toBe(0);
-    });
-    it("each runner instance is independent (no shared mutable state on the class)", () => {
-        const a = new StreamRunner(makeDeps());
-        const b = new StreamRunner(makeDeps());
-        expect(a).not.toBe(b);
-    });
-    describe("StreamRunner — maxSteps custom overrides", () => {
-        it("respects default maxSteps logic when request.maxToolRounds is undefined", async () => {
-            const deps = makeDeps({ getMaxToolRounds: () => 50 });
-            const runner = new StreamRunner(deps);
-            const outcome = await runner.setup({
-                agent: "explore",
-                description: "test",
-                prompt: "test",
-            });
-            expect(outcome.kind).toBe("prepared");
-            if (outcome.kind === "prepared") {
-                expect(outcome.prepared.maxSteps).toBe(100); // deps.getMaxToolRounds() * 2
-            }
-        });
-        it("uses request.maxToolRounds when it is explicitly defined", async () => {
-            const deps = makeDeps({ getMaxToolRounds: () => 50 });
-            const runner = new StreamRunner(deps);
-            const outcome = await runner.setup({
-                agent: "explore",
-                description: "test",
-                prompt: "test",
-                maxToolRounds: 75,
-            });
-            expect(outcome.kind).toBe("prepared");
-            if (outcome.kind === "prepared") {
-                expect(outcome.prepared.maxSteps).toBe(75);
-            }
-        });
-    });
-});
-//# sourceMappingURL=stream-runner.test.js.map

package/dist/src/orchestrator/__tests__/sub-agent-model-tier.test.d.ts

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

package/dist/src/orchestrator/__tests__/sub-agent-model-tier.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveModelForTask, TASK_TIER_PREFS } from "../sub-agent-model-tier.js";
-// A fake provider catalog: "acme" has a full ladder; "premOnly" has premium only.
-function makeLookup() {
-    const table = {
-        acme: {
-            fast: { id: "acme-fast", provider: "acme" },
-            balanced: { id: "acme-balanced", provider: "acme" },
-            premium: { id: "acme-premium", provider: "acme" },
-        },
-        premOnly: {
-            premium: { id: "prem-premium", provider: "premOnly" },
-        },
-    };
-    return (tier, preferProvider) => (preferProvider ? table[preferProvider]?.[tier] : undefined);
-}
-describe("sub-agent model tier policy", () => {
-    const lookup = makeLookup();
-    it("downgrades a general sub-agent to balanced (gap #2 fix)", () => {
-        expect(resolveModelForTask("general", "acme", "acme-premium", lookup)).toBe("acme-balanced");
-    });
-    it("keeps verify on premium (rigor over cost)", () => {
-        expect(resolveModelForTask("verify", "acme", "acme-premium", lookup)).toBe("acme-premium");
-    });
-    it("explore prefers balanced", () => {
-        expect(resolveModelForTask("explore", "acme", "acme-premium", lookup)).toBe("acme-balanced");
-    });
-    it("compact/title prefer the cheapest tier", () => {
-        expect(resolveModelForTask("compact", "acme", "acme-premium", lookup)).toBe("acme-fast");
-        expect(resolveModelForTask("title", "acme", "acme-premium", lookup)).toBe("acme-fast");
-    });
-    it("falls back to the parent model when the provider has no cheaper tier", () => {
-        // premOnly has only premium → general's [balanced, premium] resolves premium.
-        expect(resolveModelForTask("general", "premOnly", "prem-premium", lookup)).toBe("prem-premium");
-    });
-    it("never crosses providers — unknown provider yields the fallback model", () => {
-        expect(resolveModelForTask("general", "unknown", "parent-model", lookup)).toBe("parent-model");
-    });
-    it("policy intent is documented in the tier map", () => {
-        // general downgrades (balanced before premium); verify does not.
-        expect(TASK_TIER_PREFS.general.indexOf("balanced")).toBeLessThan(TASK_TIER_PREFS.general.indexOf("premium"));
-        expect(TASK_TIER_PREFS.verify.indexOf("premium")).toBeLessThan(TASK_TIER_PREFS.verify.indexOf("balanced"));
-    });
-});
-//# sourceMappingURL=sub-agent-model-tier.test.js.map

package/dist/src/orchestrator/__tests__/usage-events-shape.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * src/orchestrator/__tests__/usage-events-shape.test.ts
- *
- * Phase O1 — integration check that `recordUsageEvent` threads
- * `providerOptionsShape` through to the INSERT statement on `usage_events`.
- * Mirrors the mock-db pattern from write-ahead.test.ts.
- */
-export {};

package/dist/src/orchestrator/__tests__/usage-events-shape.test.js

@@ -1,58 +0,0 @@
-/**
- * src/orchestrator/__tests__/usage-events-shape.test.ts
- *
- * Phase O1 — integration check that `recordUsageEvent` threads
- * `providerOptionsShape` through to the INSERT statement on `usage_events`.
- * Mirrors the mock-db pattern from write-ahead.test.ts.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const preparedCalls = [];
-vi.mock("../../storage/db", () => {
-    const makeDb = () => ({
-        prepare: (sql) => ({
-            run: (...args) => {
-                preparedCalls.push({ sql, runArgs: args });
-                return undefined;
-            },
-            get: () => undefined,
-            all: () => [],
-        }),
-        exec: () => undefined,
-        pragma: () => undefined,
-        transaction: (fn) => fn,
-        close: () => undefined,
-    });
-    return {
-        getDatabase: () => makeDb(),
-        withTransaction: (fn) => fn(makeDb()),
-    };
-});
-// Import AFTER the mock so usage.ts picks up the mocked db.
-import { recordUsageEvent } from "../../storage/usage.js";
-describe("O1: usage_events INSERT carries provider_options_shape", () => {
-    beforeEach(() => {
-        preparedCalls.length = 0;
-    });
-    afterEach(() => {
-        preparedCalls.length = 0;
-    });
-    it("includes provider_options_shape column in INSERT and passes shape JSON as the trailing param", () => {
-        const shape = JSON.stringify({ openai: { store: "boolean", promptCacheKey: "string" } });
-        recordUsageEvent("sess-1", "message", "gpt-5.4", { inputTokens: 100, outputTokens: 50, totalTokens: 150 }, 7, false, 0, shape);
-        expect(preparedCalls).toHaveLength(1);
-        const call = preparedCalls[0];
-        expect(call.sql).toMatch(/INSERT INTO usage_events/);
-        expect(call.sql).toMatch(/provider_options_shape/);
-        // 14 columns now: 13 prior + provider_options_shape. The shape value
-        // should be the LAST runArg.
-        expect(call.runArgs).toHaveLength(14);
-        expect(call.runArgs[call.runArgs.length - 1]).toBe(shape);
-    });
-    it("defaults provider_options_shape to null when caller omits it (backwards compat)", () => {
-        recordUsageEvent("sess-2", "title", "gpt-5.4", { inputTokens: 10, outputTokens: 5, totalTokens: 15 }, null);
-        expect(preparedCalls).toHaveLength(1);
-        const call = preparedCalls[0];
-        expect(call.runArgs[call.runArgs.length - 1]).toBeNull();
-    });
-});
-//# sourceMappingURL=usage-events-shape.test.js.map

package/dist/src/orchestrator/__tests__/usage-normalizer-c1.test.d.ts

@@ -1,21 +0,0 @@
-/**
- * src/orchestrator/__tests__/usage-normalizer-c1.test.ts
- *
- * Phase C1 — DeepSeek cache-token field reading.
- *
- * Before the fix, `getUsage()` and `getBatchUsage()` only consulted
- * `event.usage.cachedInputTokens`, `event.usage.inputTokenDetails.*`, and
- * `event.usage.raw.cache_creation_input_tokens`. DeepSeek goes through
- * `@ai-sdk/openai-compatible`, which exposes its cache split via
- * `providerMetadata.deepseek.{promptCacheHitTokens, promptCacheMissTokens}`
- * (streaming events) or raw `prompt_cache_hit_tokens` / `prompt_cache_miss_tokens`
- * fields (batch responses). Neither path was being read, so every DeepSeek
- * request recorded `cache_read_tokens = 0` — flagged by `usage forensics`
- * as "zero cache_creation across deepseek route — Phase C1 still open".
- *
- * This spec pins the new behavior:
- *   - DeepSeek-shaped batch usage → cacheReadTokens=700, noCacheInputTokens=300
- *   - DeepSeek-shaped streaming event (providerMetadata path) → same
- *   - OpenAI-shaped usage → unchanged (no DeepSeek-specific fields read)
- */
-export {};