@renseiai/agentfactory 0.8.8 → 0.8.9

package/dist/src/routing/reward.test.js

@@ -0,0 +1,210 @@
+import { describe, it, expect } from 'vitest';
+import { computeReward, extractRewardFromProcess, MAX_EXPECTED_COST } from './reward.js';
+function makeReward(overrides = {}) {
+    return {
+        taskCompleted: false,
+        prCreated: false,
+        qaResult: 'unknown',
+        totalCostUsd: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        wallClockTimeMs: 0,
+        requiredRefinements: 0,
+        humanEscalations: 0,
+        ...overrides,
+    };
+}
+function makeProcess(overrides = {}) {
+    return {
+        issueId: 'issue-1',
+        identifier: 'SUP-100',
+        pid: 1234,
+        status: 'running',
+        startedAt: new Date('2024-01-01T00:00:00Z'),
+        lastActivityAt: new Date('2024-01-01T00:01:00Z'),
+        ...overrides,
+    };
+}
+describe('computeReward', () => {
+    it('returns ~1.0 for full success with zero cost', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: 0,
+        }));
+        // 0.5 + 0.2 + 0.3 - 0 = 1.0
+        expect(reward).toBe(1.0);
+    });
+    it('returns 0.0 for full failure', () => {
+        const reward = computeReward(makeReward());
+        expect(reward).toBe(0.0);
+    });
+    it('returns 0.5 for taskCompleted only', () => {
+        const reward = computeReward(makeReward({ taskCompleted: true }));
+        expect(reward).toBe(0.5);
+    });
+    it('returns 0.2 for prCreated only', () => {
+        const reward = computeReward(makeReward({ prCreated: true }));
+        expect(reward).toBe(0.2);
+    });
+    it('returns 0.3 for qaResult passed only', () => {
+        const reward = computeReward(makeReward({ qaResult: 'passed' }));
+        expect(reward).toBe(0.3);
+    });
+    it('returns 0.7 for taskCompleted + prCreated', () => {
+        const reward = computeReward(makeReward({ taskCompleted: true, prCreated: true }));
+        expect(reward).toBe(0.7);
+    });
+    it('applies full cost penalty of 0.1 when cost equals MAX_EXPECTED_COST', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: MAX_EXPECTED_COST,
+        }));
+        // 0.5 + 0.2 + 0.3 - 0.1 * 1.0 = 0.9
+        expect(reward).toBeCloseTo(0.9);
+    });
+    it('caps cost penalty when cost exceeds MAX_EXPECTED_COST', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: 100,
+        }));
+        // Cost penalty capped at 0.1, so 1.0 - 0.1 = 0.9
+        expect(reward).toBeCloseTo(0.9);
+    });
+    it('applies proportional cost penalty', () => {
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            totalCostUsd: MAX_EXPECTED_COST / 2,
+        }));
+        // 0.5 - 0.1 * 0.5 = 0.45
+        expect(reward).toBeCloseTo(0.45);
+    });
+    it('clamps reward to minimum of 0', () => {
+        // Only cost, no success signals: 0 - 0.1 = -0.1 => clamped to 0
+        const reward = computeReward(makeReward({ totalCostUsd: MAX_EXPECTED_COST }));
+        expect(reward).toBe(0);
+    });
+    it('clamps reward to maximum of 1', () => {
+        // Full success with zero cost should be exactly 1.0 (0.5 + 0.2 + 0.3)
+        const reward = computeReward(makeReward({
+            taskCompleted: true,
+            prCreated: true,
+            qaResult: 'passed',
+            totalCostUsd: 0,
+        }));
+        expect(reward).toBeLessThanOrEqual(1);
+        expect(reward).toBeGreaterThanOrEqual(0);
+    });
+    it('does not add reward for qaResult failed', () => {
+        const reward = computeReward(makeReward({ qaResult: 'failed' }));
+        expect(reward).toBe(0);
+    });
+    it('does not add reward for qaResult unknown', () => {
+        const reward = computeReward(makeReward({ qaResult: 'unknown' }));
+        expect(reward).toBe(0);
+    });
+});
+describe('extractRewardFromProcess', () => {
+    it('maps completed process with PR and passed QA', () => {
+        const process = makeProcess({
+            status: 'completed',
+            pullRequestUrl: 'https://github.com/org/repo/pull/1',
+            workResult: 'passed',
+            totalCostUsd: 1.5,
+            inputTokens: 10000,
+            outputTokens: 5000,
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: new Date('2024-01-01T00:05:00Z'),
+        });
+        const result = extractRewardFromProcess(process);
+        expect(result.taskCompleted).toBe(true);
+        expect(result.prCreated).toBe(true);
+        expect(result.qaResult).toBe('passed');
+        expect(result.totalCostUsd).toBe(1.5);
+        expect(result.inputTokens).toBe(10000);
+        expect(result.outputTokens).toBe(5000);
+        expect(result.wallClockTimeMs).toBe(300000); // 5 minutes
+        expect(result.requiredRefinements).toBe(0);
+        expect(result.humanEscalations).toBe(0);
+    });
+    it('maps failed process', () => {
+        const process = makeProcess({
+            status: 'failed',
+        });
+        const result = extractRewardFromProcess(process);
+        expect(result.taskCompleted).toBe(false);
+        expect(result.prCreated).toBe(false);
+        expect(result.qaResult).toBe('unknown');
+    });
+    it('maps running process as not completed', () => {
+        const result = extractRewardFromProcess(makeProcess({ status: 'running' }));
+        expect(result.taskCompleted).toBe(false);
+    });
+    it('maps incomplete process as not completed', () => {
+        const result = extractRewardFromProcess(makeProcess({ status: 'incomplete' }));
+        expect(result.taskCompleted).toBe(false);
+    });
+    it('maps stopped process as not completed', () => {
+        const result = extractRewardFromProcess(makeProcess({ status: 'stopped' }));
+        expect(result.taskCompleted).toBe(false);
+    });
+    it('handles undefined pullRequestUrl', () => {
+        const result = extractRewardFromProcess(makeProcess({ pullRequestUrl: undefined }));
+        expect(result.prCreated).toBe(false);
+    });
+    it('handles undefined workResult', () => {
+        const result = extractRewardFromProcess(makeProcess({ workResult: undefined }));
+        expect(result.qaResult).toBe('unknown');
+    });
+    it('handles undefined totalCostUsd', () => {
+        const result = extractRewardFromProcess(makeProcess({ totalCostUsd: undefined }));
+        expect(result.totalCostUsd).toBe(0);
+    });
+    it('handles undefined inputTokens', () => {
+        const result = extractRewardFromProcess(makeProcess({ inputTokens: undefined }));
+        expect(result.inputTokens).toBe(0);
+    });
+    it('handles undefined outputTokens', () => {
+        const result = extractRewardFromProcess(makeProcess({ outputTokens: undefined }));
+        expect(result.outputTokens).toBe(0);
+    });
+    it('handles undefined completedAt (wallClockTimeMs is 0)', () => {
+        const result = extractRewardFromProcess(makeProcess({
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: undefined,
+        }));
+        expect(result.wallClockTimeMs).toBe(0);
+    });
+    it('computes correct wallClockTimeMs from startedAt and completedAt', () => {
+        const result = extractRewardFromProcess(makeProcess({
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: new Date('2024-01-01T01:00:00Z'),
+        }));
+        expect(result.wallClockTimeMs).toBe(3600000); // 1 hour
+    });
+    it('end-to-end: extractRewardFromProcess feeds into computeReward correctly', () => {
+        const process = makeProcess({
+            status: 'completed',
+            pullRequestUrl: 'https://github.com/org/repo/pull/1',
+            workResult: 'passed',
+            totalCostUsd: 0,
+        });
+        const routingReward = extractRewardFromProcess(process);
+        const reward = computeReward(routingReward);
+        expect(reward).toBe(1.0);
+    });
+    it('end-to-end: failed process with high cost yields 0', () => {
+        const process = makeProcess({
+            status: 'failed',
+            totalCostUsd: 10,
+        });
+        const routingReward = extractRewardFromProcess(process);
+        const reward = computeReward(routingReward);
+        expect(reward).toBe(0);
+    });
+});

package/dist/src/routing/routing-engine.d.ts

@@ -0,0 +1,20 @@
+import type { AgentProviderName } from '../providers/types.js';
+import type { AgentWorkType } from '../orchestrator/work-types.js';
+import type { RoutingDecision, RoutingConfig } from './types.js';
+import type { PosteriorStore } from './posterior-store.js';
+export declare const DEFAULT_ROUTING_CONFIG: RoutingConfig;
+export declare function betaMean(alpha: number, beta: number): number;
+export declare function betaVariance(alpha: number, beta: number): number;
+/**
+ * Sample from a Beta distribution using the ratio of Gamma variates.
+ * If X ~ Gamma(alpha), Y ~ Gamma(beta), then X/(X+Y) ~ Beta(alpha, beta).
+ *
+ * If a random generator is provided, use it for deterministic testing.
+ */
+export declare function betaSample(alpha: number, beta: number, rng?: () => number): number;
+export interface SelectProviderOptions {
+    forcedExploration?: boolean;
+    rng?: () => number;
+}
+export declare function selectProvider(posteriorStore: PosteriorStore, workType: AgentWorkType, availableProviders: AgentProviderName[], config?: RoutingConfig, opts?: SelectProviderOptions): Promise<RoutingDecision>;
+//# sourceMappingURL=routing-engine.d.ts.map

package/dist/src/routing/routing-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-engine.d.ts","sourceRoot":"","sources":["../../../src/routing/routing-engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,eAAO,MAAM,sBAAsB,EAAE,aAOpC,CAAA;AAGD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,MAAM,GAAG,MAAM,CAQlF;AAkCD,MAAM,WAAW,qBAAqB;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,wBAAsB,cAAc,CAClC,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,aAAa,EACvB,kBAAkB,EAAE,iBAAiB,EAAE,EACvC,MAAM,GAAE,aAAsC,EAC9C,IAAI,CAAC,EAAE,qBAAqB,GAC3B,OAAO,CAAC,eAAe,CAAC,CAgE1B"}

package/dist/src/routing/routing-engine.js

@@ -0,0 +1,113 @@
+export const DEFAULT_ROUTING_CONFIG = {
+    enabled: false,
+    explorationRate: 0.1,
+    windowSize: 100,
+    discountFactor: 0.99,
+    minObservationsForExploit: 5,
+    changeDetectionThreshold: 0.2,
+};
+// Beta distribution utilities - pure math, no external dependencies
+export function betaMean(alpha, beta) {
+    return alpha / (alpha + beta);
+}
+export function betaVariance(alpha, beta) {
+    const ab = alpha + beta;
+    return (alpha * beta) / (ab * ab * (ab + 1));
+}
+/**
+ * Sample from a Beta distribution using the ratio of Gamma variates.
+ * If X ~ Gamma(alpha), Y ~ Gamma(beta), then X/(X+Y) ~ Beta(alpha, beta).
+ *
+ * If a random generator is provided, use it for deterministic testing.
+ */
+export function betaSample(alpha, beta, rng) {
+    const random = rng ?? Math.random;
+    const x = gammaSample(alpha, random);
+    const y = gammaSample(beta, random);
+    if (x + y === 0)
+        return 0.5; // Edge case
+    return x / (x + y);
+}
+/**
+ * Sample from a Gamma distribution using Marsaglia and Tsang's method.
+ */
+function gammaSample(shape, random) {
+    if (shape < 1) {
+        // For shape < 1, use the trick: Gamma(shape) = Gamma(shape+1) * U^(1/shape)
+        return gammaSample(shape + 1, random) * Math.pow(random(), 1 / shape);
+    }
+    const d = shape - 1 / 3;
+    const c = 1 / Math.sqrt(9 * d);
+    while (true) {
+        let x;
+        let v;
+        do {
+            // Generate standard normal using Box-Muller
+            const u1 = random();
+            const u2 = random();
+            x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+            v = 1 + c * x;
+        } while (v <= 0);
+        v = v * v * v;
+        const u = random();
+        if (u < 1 - 0.0331 * (x * x) * (x * x))
+            return d * v;
+        if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v)))
+            return d * v;
+    }
+}
+export async function selectProvider(posteriorStore, workType, availableProviders, config = DEFAULT_ROUTING_CONFIG, opts) {
+    const posteriors = await Promise.all(availableProviders.map(p => posteriorStore.getPosterior(p, workType)));
+    const rng = opts?.rng;
+    // Forced exploration: random selection
+    if (opts?.forcedExploration || (rng ?? Math.random)() < config.explorationRate) {
+        const idx = Math.floor((rng ?? Math.random)() * availableProviders.length);
+        const chosen = posteriors[idx];
+        const mean = betaMean(chosen.alpha, chosen.beta);
+        const confidence = 1 - Math.sqrt(betaVariance(chosen.alpha, chosen.beta));
+        const others = posteriors
+            .filter((_, i) => i !== idx)
+            .map(p => ({
+            provider: p.provider,
+            expectedReward: betaMean(p.alpha, p.beta),
+            confidence: 1 - Math.sqrt(betaVariance(p.alpha, p.beta)),
+        }));
+        return {
+            selectedProvider: chosen.provider,
+            confidence,
+            expectedReward: mean,
+            explorationReason: 'forced',
+            source: 'mab-routing',
+            alternatives: others,
+        };
+    }
+    // Thompson Sampling: draw from each posterior's Beta distribution
+    const samples = posteriors.map(post => ({
+        provider: post.provider,
+        sample: betaSample(post.alpha, post.beta, rng),
+        confidence: 1 - Math.sqrt(betaVariance(post.alpha, post.beta)),
+        expectedReward: betaMean(post.alpha, post.beta),
+    }));
+    // Select highest sample
+    samples.sort((a, b) => b.sample - a.sample);
+    const selected = samples[0];
+    // Only trust posteriors with enough observations
+    const selectedPosterior = posteriors.find(p => p.provider === selected.provider);
+    const isTrusted = selectedPosterior.totalObservations >= config.minObservationsForExploit;
+    return {
+        selectedProvider: selected.provider,
+        confidence: selected.confidence,
+        expectedReward: selected.expectedReward,
+        explorationReason: !isTrusted
+            ? 'uncertainty'
+            : selected.confidence < 0.3
+                ? 'uncertainty'
+                : undefined,
+        source: 'mab-routing',
+        alternatives: samples.slice(1).map(s => ({
+            provider: s.provider,
+            expectedReward: s.expectedReward,
+            confidence: s.confidence,
+        })),
+    };
+}

package/dist/src/routing/routing-engine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=routing-engine.test.d.ts.map

package/dist/src/routing/routing-engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-engine.test.d.ts","sourceRoot":"","sources":["../../../src/routing/routing-engine.test.ts"],"names":[],"mappings":""}

package/dist/src/routing/routing-engine.test.js

@@ -0,0 +1,310 @@
+import { describe, it, expect, vi } from 'vitest';
+import { betaMean, betaVariance, betaSample, selectProvider, DEFAULT_ROUTING_CONFIG, } from './routing-engine.js';
+function makePosterior(overrides = {}) {
+    return {
+        provider: 'claude',
+        workType: 'development',
+        alpha: 1,
+        beta: 1,
+        totalObservations: 0,
+        avgReward: 0,
+        avgCostUsd: 0,
+        lastUpdated: Date.now(),
+        ...overrides,
+    };
+}
+function makeMockStore(posteriors) {
+    return {
+        getPosterior: vi.fn(async (provider, workType) => {
+            const key = `${provider}:${workType}`;
+            return posteriors[key] ?? makePosterior({ provider, workType });
+        }),
+        updatePosterior: vi.fn(async () => makePosterior()),
+        getAllPosteriors: vi.fn(async () => Object.values(posteriors)),
+        resetPosterior: vi.fn(async () => { }),
+    };
+}
+/**
+ * Create a deterministic RNG from a seed using a simple LCG.
+ * This allows reproducible tests.
+ */
+function seededRng(seed) {
+    let state = seed;
+    return () => {
+        // LCG parameters (Numerical Recipes)
+        state = (state * 1664525 + 1013904223) & 0xffffffff;
+        return (state >>> 0) / 0x100000000;
+    };
+}
+describe('betaMean', () => {
+    it('returns correct mean for Beta(1,1) = 0.5', () => {
+        expect(betaMean(1, 1)).toBe(0.5);
+    });
+    it('returns correct mean for Beta(2,1) ~ 0.667', () => {
+        expect(betaMean(2, 1)).toBeCloseTo(2 / 3, 5);
+    });
+    it('returns correct mean for Beta(5,5) = 0.5', () => {
+        expect(betaMean(5, 5)).toBe(0.5);
+    });
+    it('returns correct mean for Beta(10,2) ~ 0.833', () => {
+        expect(betaMean(10, 2)).toBeCloseTo(10 / 12, 5);
+    });
+});
+describe('betaVariance', () => {
+    it('returns correct variance for Beta(1,1) = 1/12', () => {
+        expect(betaVariance(1, 1)).toBeCloseTo(1 / 12, 10);
+    });
+    it('returns correct variance for Beta(2,2) = 1/20', () => {
+        // Var = 2*2 / (4*4*5) = 4/80 = 1/20
+        expect(betaVariance(2, 2)).toBeCloseTo(1 / 20, 10);
+    });
+    it('returns smaller variance with more observations (higher alpha+beta)', () => {
+        const varLow = betaVariance(2, 2);
+        const varHigh = betaVariance(20, 20);
+        expect(varHigh).toBeLessThan(varLow);
+    });
+});
+describe('betaSample', () => {
+    it('returns values between 0 and 1', () => {
+        const rng = seededRng(42);
+        for (let i = 0; i < 100; i++) {
+            const sample = betaSample(2, 3, rng);
+            expect(sample).toBeGreaterThanOrEqual(0);
+            expect(sample).toBeLessThanOrEqual(1);
+        }
+    });
+    it('with deterministic RNG produces consistent results', () => {
+        const rng1 = seededRng(12345);
+        const rng2 = seededRng(12345);
+        const sample1 = betaSample(3, 5, rng1);
+        const sample2 = betaSample(3, 5, rng2);
+        expect(sample1).toBe(sample2);
+    });
+    it('mean approximates betaMean over many samples (statistical test)', () => {
+        const alpha = 4;
+        const beta = 8;
+        const rng = seededRng(999);
+        const n = 5000;
+        let sum = 0;
+        for (let i = 0; i < n; i++) {
+            sum += betaSample(alpha, beta, rng);
+        }
+        const empiricalMean = sum / n;
+        const theoreticalMean = betaMean(alpha, beta);
+        // Allow 5% tolerance for statistical convergence
+        expect(empiricalMean).toBeCloseTo(theoreticalMean, 1);
+    });
+    it('works with alpha < 1 and beta < 1', () => {
+        const rng = seededRng(77);
+        for (let i = 0; i < 50; i++) {
+            const sample = betaSample(0.5, 0.5, rng);
+            expect(sample).toBeGreaterThanOrEqual(0);
+            expect(sample).toBeLessThanOrEqual(1);
+        }
+    });
+    it('works with large alpha and beta', () => {
+        const rng = seededRng(88);
+        for (let i = 0; i < 50; i++) {
+            const sample = betaSample(100, 100, rng);
+            expect(sample).toBeGreaterThanOrEqual(0);
+            expect(sample).toBeLessThanOrEqual(1);
+        }
+    });
+});
+describe('selectProvider', () => {
+    const workType = 'development';
+    const providers = ['claude', 'codex', 'amp'];
+    it('returns a valid RoutingDecision', async () => {
+        const store = makeMockStore({});
+        const rng = seededRng(42);
+        const decision = await selectProvider(store, workType, providers, DEFAULT_ROUTING_CONFIG, {
+            rng,
+        });
+        expect(decision.selectedProvider).toBeDefined();
+        expect(providers).toContain(decision.selectedProvider);
+        expect(decision.confidence).toBeGreaterThanOrEqual(0);
+        expect(decision.confidence).toBeLessThanOrEqual(1);
+        expect(decision.expectedReward).toBeGreaterThanOrEqual(0);
+        expect(decision.expectedReward).toBeLessThanOrEqual(1);
+        expect(decision.source).toBe('mab-routing');
+        expect(Array.isArray(decision.alternatives)).toBe(true);
+    });
+    it('with forced exploration selects randomly and marks explorationReason as forced', async () => {
+        const store = makeMockStore({
+            'claude:development': makePosterior({
+                provider: 'claude',
+                workType: 'development',
+                alpha: 100,
+                beta: 1,
+                totalObservations: 100,
+            }),
+            'codex:development': makePosterior({
+                provider: 'codex',
+                workType: 'development',
+                alpha: 1,
+                beta: 100,
+                totalObservations: 100,
+            }),
+        });
+        const rng = seededRng(42);
+        const decision = await selectProvider(store, workType, ['claude', 'codex'], DEFAULT_ROUTING_CONFIG, {
+            forcedExploration: true,
+            rng,
+        });
+        expect(decision.explorationReason).toBe('forced');
+        expect(['claude', 'codex']).toContain(decision.selectedProvider);
+    });
+    it('picks provider with highest sampled reward (deterministic RNG)', async () => {
+        // Give claude a very strong posterior (alpha=50, beta=2) -- mean ~0.96
+        // Give codex a very weak posterior (alpha=2, beta=50) -- mean ~0.04
+        const store = makeMockStore({
+            'claude:development': makePosterior({
+                provider: 'claude',
+                workType: 'development',
+                alpha: 50,
+                beta: 2,
+                totalObservations: 50,
+            }),
+            'codex:development': makePosterior({
+                provider: 'codex',
+                workType: 'development',
+                alpha: 2,
+                beta: 50,
+                totalObservations: 50,
+            }),
+        });
+        // Use a config with 0 exploration rate so TS runs
+        const config = { ...DEFAULT_ROUTING_CONFIG, explorationRate: 0 };
+        // Run multiple times -- claude should almost always be picked
+        let claudeCount = 0;
+        for (let i = 0; i < 20; i++) {
+            const rng = seededRng(i * 137);
+            const decision = await selectProvider(store, workType, ['claude', 'codex'], config, { rng });
+            if (decision.selectedProvider === 'claude')
+                claudeCount++;
+        }
+        // Claude should win the vast majority of the time
+        expect(claudeCount).toBeGreaterThanOrEqual(18);
+    });
+    it('marks low-observation providers with explorationReason uncertainty', async () => {
+        const store = makeMockStore({
+            'claude:development': makePosterior({
+                provider: 'claude',
+                workType: 'development',
+                alpha: 2,
+                beta: 1,
+                totalObservations: 2, // Below minObservationsForExploit (5)
+            }),
+        });
+        const config = { ...DEFAULT_ROUTING_CONFIG, explorationRate: 0 };
+        const rng = seededRng(42);
+        const decision = await selectProvider(store, workType, ['claude'], config, { rng });
+        expect(decision.explorationReason).toBe('uncertainty');
+    });
+    it('explores with probability = explorationRate', async () => {
+        const store = makeMockStore({
+            'claude:development': makePosterior({
+                provider: 'claude',
+                workType: 'development',
+                alpha: 10,
+                beta: 10,
+                totalObservations: 20,
+            }),
+            'codex:development': makePosterior({
+                provider: 'codex',
+                workType: 'development',
+                alpha: 10,
+                beta: 10,
+                totalObservations: 20,
+            }),
+        });
+        const explorationRate = 0.5;
+        const config = { ...DEFAULT_ROUTING_CONFIG, explorationRate };
+        let forcedCount = 0;
+        const n = 200;
+        for (let i = 0; i < n; i++) {
+            const rng = seededRng(i * 31);
+            const decision = await selectProvider(store, workType, ['claude', 'codex'], config, { rng });
+            if (decision.explorationReason === 'forced')
+                forcedCount++;
+        }
+        // Exploration should happen roughly explorationRate fraction of the time
+        // Allow generous tolerance for randomness
+        const fraction = forcedCount / n;
+        expect(fraction).toBeGreaterThan(0.3);
+        expect(fraction).toBeLessThan(0.7);
+    });
+    it('includes alternatives array excluding the selected provider', async () => {
+        const store = makeMockStore({});
+        const rng = seededRng(42);
+        const decision = await selectProvider(store, workType, providers, DEFAULT_ROUTING_CONFIG, {
+            rng,
+        });
+        // Alternatives should not contain the selected provider
+        const altProviders = decision.alternatives.map(a => a.provider);
+        expect(altProviders).not.toContain(decision.selectedProvider);
+        // Alternatives + selected should cover all providers
+        expect(altProviders.length).toBe(providers.length - 1);
+    });
+    it('handles single provider (no alternatives)', async () => {
+        const store = makeMockStore({});
+        const rng = seededRng(42);
+        const decision = await selectProvider(store, workType, ['claude'], DEFAULT_ROUTING_CONFIG, { rng });
+        expect(decision.selectedProvider).toBe('claude');
+        expect(decision.alternatives).toHaveLength(0);
+    });
+    it('with deterministic RNG produces consistent selection', async () => {
+        const store = makeMockStore({
+            'claude:development': makePosterior({
+                provider: 'claude',
+                workType: 'development',
+                alpha: 5,
+                beta: 5,
+                totalObservations: 10,
+            }),
+            'codex:development': makePosterior({
+                provider: 'codex',
+                workType: 'development',
+                alpha: 3,
+                beta: 7,
+                totalObservations: 10,
+            }),
+        });
+        const config = { ...DEFAULT_ROUTING_CONFIG, explorationRate: 0 };
+        const rng1 = seededRng(555);
+        const decision1 = await selectProvider(store, workType, ['claude', 'codex'], config, {
+            rng: rng1,
+        });
+        const rng2 = seededRng(555);
+        const decision2 = await selectProvider(store, workType, ['claude', 'codex'], config, {
+            rng: rng2,
+        });
+        expect(decision1.selectedProvider).toBe(decision2.selectedProvider);
+        expect(decision1.expectedReward).toBe(decision2.expectedReward);
+        expect(decision1.confidence).toBe(decision2.confidence);
+    });
+    it('does not mark explorationReason when provider has sufficient observations and high confidence', async () => {
+        const store = makeMockStore({
+            'claude:development': makePosterior({
+                provider: 'claude',
+                workType: 'development',
+                alpha: 50,
+                beta: 5,
+                totalObservations: 55, // Well above minObservationsForExploit
+            }),
+        });
+        const config = { ...DEFAULT_ROUTING_CONFIG, explorationRate: 0 };
+        const rng = seededRng(42);
+        const decision = await selectProvider(store, workType, ['claude'], config, { rng });
+        expect(decision.explorationReason).toBeUndefined();
+    });
+    it('calls getPosterior for each available provider', async () => {
+        const store = makeMockStore({});
+        const rng = seededRng(42);
+        await selectProvider(store, workType, providers, DEFAULT_ROUTING_CONFIG, { rng });
+        expect(store.getPosterior).toHaveBeenCalledTimes(3);
+        expect(store.getPosterior).toHaveBeenCalledWith('claude', 'development');
+        expect(store.getPosterior).toHaveBeenCalledWith('codex', 'development');
+        expect(store.getPosterior).toHaveBeenCalledWith('amp', 'development');
+    });
+});