@renseiai/agentfactory 0.8.8 → 0.8.9

package/dist/src/routing/observation-recorder.test.js

@@ -0,0 +1,322 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { buildObservation, wrapEventsWithRecorder } from './observation-recorder.js';
+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,
+    };
+}
+function makeMockStores() {
+    const observationStore = {
+        recordObservation: vi.fn().mockResolvedValue(undefined),
+        getObservations: vi.fn().mockResolvedValue([]),
+        getRecentObservations: vi.fn().mockResolvedValue([]),
+    };
+    const posteriorStore = {
+        getPosterior: vi.fn().mockResolvedValue({}),
+        updatePosterior: vi.fn().mockResolvedValue({}),
+        getAllPosteriors: vi.fn().mockResolvedValue([]),
+        resetPosterior: vi.fn().mockResolvedValue(undefined),
+    };
+    return { observationStore, posteriorStore };
+}
+describe('buildObservation', () => {
+    it('returns null when providerName is missing', () => {
+        const agent = makeProcess({
+            providerName: undefined,
+            workType: 'development',
+        });
+        expect(buildObservation(agent)).toBeNull();
+    });
+    it('returns null when workType is missing', () => {
+        const agent = makeProcess({
+            providerName: 'claude',
+            workType: undefined,
+        });
+        expect(buildObservation(agent)).toBeNull();
+    });
+    it('correctly maps completed agent to observation', () => {
+        const agent = makeProcess({
+            status: 'completed',
+            providerName: 'claude',
+            workType: 'development',
+            pullRequestUrl: 'https://github.com/org/repo/pull/42',
+            workResult: 'passed',
+            totalCostUsd: 1.5,
+            sessionId: 'session-123',
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: new Date('2024-01-01T00:05:00Z'),
+        });
+        const obs = buildObservation(agent);
+        expect(obs).not.toBeNull();
+        expect(obs.provider).toBe('claude');
+        expect(obs.workType).toBe('development');
+        expect(obs.issueIdentifier).toBe('SUP-100');
+        expect(obs.sessionId).toBe('session-123');
+        expect(obs.taskCompleted).toBe(true);
+        expect(obs.prCreated).toBe(true);
+        expect(obs.qaResult).toBe('passed');
+        expect(obs.totalCostUsd).toBe(1.5);
+        expect(obs.wallClockMs).toBe(300000); // 5 minutes
+        // reward for completed + PR + passed QA with some cost
+        expect(obs.reward).toBeGreaterThan(0);
+        expect(obs.reward).toBeLessThanOrEqual(1);
+        expect(obs.confidence).toBe(0);
+        expect(obs.explorationReason).toBeUndefined();
+        expect(obs.id).toBeDefined();
+        expect(obs.timestamp).toBeGreaterThan(0);
+    });
+    it('correctly maps failed agent to observation with reward near 0', () => {
+        const agent = makeProcess({
+            status: 'failed',
+            providerName: 'codex',
+            workType: 'qa',
+            totalCostUsd: 3.0,
+        });
+        const obs = buildObservation(agent);
+        expect(obs).not.toBeNull();
+        expect(obs.taskCompleted).toBe(false);
+        expect(obs.prCreated).toBe(false);
+        expect(obs.qaResult).toBe('unknown');
+        // No success signals, only cost penalty => reward should be 0
+        expect(obs.reward).toBe(0);
+    });
+    it('correctly maps stopped agent to observation', () => {
+        const agent = makeProcess({
+            status: 'stopped',
+            providerName: 'amp',
+            workType: 'research',
+            stopReason: 'timeout',
+            totalCostUsd: 0.5,
+            startedAt: new Date('2024-01-01T00:00:00Z'),
+            completedAt: new Date('2024-01-01T00:02:00Z'),
+        });
+        const obs = buildObservation(agent);
+        expect(obs).not.toBeNull();
+        expect(obs.provider).toBe('amp');
+        expect(obs.workType).toBe('research');
+        expect(obs.taskCompleted).toBe(false);
+        expect(obs.wallClockMs).toBe(120000); // 2 minutes
+    });
+    it('correctly maps incomplete agent to observation', () => {
+        const agent = makeProcess({
+            status: 'incomplete',
+            providerName: 'claude',
+            workType: 'development',
+            incompleteReason: 'no_pr_created',
+            totalCostUsd: 2.0,
+        });
+        const obs = buildObservation(agent);
+        expect(obs).not.toBeNull();
+        expect(obs.taskCompleted).toBe(false);
+        expect(obs.prCreated).toBe(false);
+    });
+    it('handles missing sessionId by defaulting to empty string', () => {
+        const agent = makeProcess({
+            providerName: 'claude',
+            workType: 'development',
+            sessionId: undefined,
+        });
+        const obs = buildObservation(agent);
+        expect(obs).not.toBeNull();
+        expect(obs.sessionId).toBe('');
+    });
+    it('handles missing completedAt by setting wallClockMs to 0', () => {
+        const agent = makeProcess({
+            providerName: 'claude',
+            workType: 'development',
+            completedAt: undefined,
+        });
+        const obs = buildObservation(agent);
+        expect(obs).not.toBeNull();
+        expect(obs.wallClockMs).toBe(0);
+    });
+    it('handles missing totalCostUsd by defaulting to 0', () => {
+        const agent = makeProcess({
+            providerName: 'claude',
+            workType: 'development',
+            totalCostUsd: undefined,
+        });
+        const obs = buildObservation(agent);
+        expect(obs).not.toBeNull();
+        expect(obs.totalCostUsd).toBe(0);
+    });
+});
+describe('wrapEventsWithRecorder', () => {
+    let stores;
+    beforeEach(() => {
+        stores = makeMockStores();
+    });
+    it('calls original onAgentComplete and records observation', async () => {
+        const originalComplete = vi.fn();
+        const events = { onAgentComplete: originalComplete };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'completed',
+            providerName: 'claude',
+            workType: 'development',
+        });
+        wrapped.onAgentComplete(agent);
+        expect(originalComplete).toHaveBeenCalledWith(agent);
+        // Allow microtask queue to flush for the void promise
+        await vi.waitFor(() => {
+            expect(stores.observationStore.recordObservation).toHaveBeenCalled();
+        });
+        expect(stores.posteriorStore.updatePosterior).toHaveBeenCalled();
+    });
+    it('calls original onAgentStopped and records observation', async () => {
+        const originalStopped = vi.fn();
+        const events = { onAgentStopped: originalStopped };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'stopped',
+            providerName: 'claude',
+            workType: 'development',
+        });
+        wrapped.onAgentStopped(agent);
+        expect(originalStopped).toHaveBeenCalledWith(agent);
+        await vi.waitFor(() => {
+            expect(stores.observationStore.recordObservation).toHaveBeenCalled();
+        });
+    });
+    it('calls original onAgentError and records observation', async () => {
+        const originalError = vi.fn();
+        const events = { onAgentError: originalError };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'failed',
+            providerName: 'claude',
+            workType: 'development',
+        });
+        const error = new Error('something broke');
+        wrapped.onAgentError(agent, error);
+        expect(originalError).toHaveBeenCalledWith(agent, error);
+        await vi.waitFor(() => {
+            expect(stores.observationStore.recordObservation).toHaveBeenCalled();
+        });
+    });
+    it('calls original onAgentIncomplete and records observation', async () => {
+        const originalIncomplete = vi.fn();
+        const events = { onAgentIncomplete: originalIncomplete };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'incomplete',
+            providerName: 'claude',
+            workType: 'development',
+        });
+        wrapped.onAgentIncomplete(agent);
+        expect(originalIncomplete).toHaveBeenCalledWith(agent);
+        await vi.waitFor(() => {
+            expect(stores.observationStore.recordObservation).toHaveBeenCalled();
+        });
+    });
+    it('gracefully handles recording failures (logs error, does not throw)', async () => {
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const recordError = new Error('store down');
+        stores.observationStore.recordObservation.mockRejectedValue(recordError);
+        const events = { onAgentComplete: vi.fn() };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'completed',
+            providerName: 'claude',
+            workType: 'development',
+        });
+        // Should not throw
+        expect(() => wrapped.onAgentComplete(agent)).not.toThrow();
+        await vi.waitFor(() => {
+            expect(consoleSpy).toHaveBeenCalledWith('[routing] Failed to record observation', expect.objectContaining({
+                error: 'store down',
+                identifier: 'SUP-100',
+            }));
+        });
+        consoleSpy.mockRestore();
+    });
+    it('passes through non-wrapped events (onAgentStart, onIssueSelected)', () => {
+        const originalStart = vi.fn();
+        const originalIssueSelected = vi.fn();
+        const originalProviderSessionId = vi.fn();
+        const originalActivityEmitted = vi.fn();
+        const events = {
+            onAgentStart: originalStart,
+            onIssueSelected: originalIssueSelected,
+            onProviderSessionId: originalProviderSessionId,
+            onActivityEmitted: originalActivityEmitted,
+        };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        // Non-wrapped events should be the original references
+        expect(wrapped.onAgentStart).toBe(originalStart);
+        expect(wrapped.onIssueSelected).toBe(originalIssueSelected);
+        expect(wrapped.onProviderSessionId).toBe(originalProviderSessionId);
+        expect(wrapped.onActivityEmitted).toBe(originalActivityEmitted);
+    });
+    it('handles undefined original callbacks gracefully', async () => {
+        const events = {};
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'completed',
+            providerName: 'claude',
+            workType: 'development',
+        });
+        // Should not throw even if original callback was undefined
+        expect(() => wrapped.onAgentComplete(agent)).not.toThrow();
+        expect(() => wrapped.onAgentStopped(agent)).not.toThrow();
+        expect(() => wrapped.onAgentError(agent, new Error('test'))).not.toThrow();
+        expect(() => wrapped.onAgentIncomplete(agent)).not.toThrow();
+        await vi.waitFor(() => {
+            // recordObservation should be called 4 times (once per event)
+            expect(stores.observationStore.recordObservation).toHaveBeenCalledTimes(4);
+        });
+    });
+    it('does not record observation when providerName is missing', async () => {
+        const events = { onAgentComplete: vi.fn() };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'completed',
+            providerName: undefined,
+            workType: 'development',
+        });
+        wrapped.onAgentComplete(agent);
+        // Give microtasks a chance to run
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        expect(stores.observationStore.recordObservation).not.toHaveBeenCalled();
+        expect(stores.posteriorStore.updatePosterior).not.toHaveBeenCalled();
+    });
+    it('does not record observation when workType is missing', async () => {
+        const events = { onAgentComplete: vi.fn() };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'completed',
+            providerName: 'claude',
+            workType: undefined,
+        });
+        wrapped.onAgentComplete(agent);
+        // Give microtasks a chance to run
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        expect(stores.observationStore.recordObservation).not.toHaveBeenCalled();
+        expect(stores.posteriorStore.updatePosterior).not.toHaveBeenCalled();
+    });
+    it('updates posterior with correct provider, workType, and reward', async () => {
+        const events = { onAgentComplete: vi.fn() };
+        const wrapped = wrapEventsWithRecorder(events, stores);
+        const agent = makeProcess({
+            status: 'completed',
+            providerName: 'claude',
+            workType: 'development',
+            pullRequestUrl: 'https://github.com/org/repo/pull/1',
+            workResult: 'passed',
+            totalCostUsd: 0,
+        });
+        wrapped.onAgentComplete(agent);
+        await vi.waitFor(() => {
+            expect(stores.posteriorStore.updatePosterior).toHaveBeenCalledWith('claude', 'development', expect.any(Number));
+        });
+        // Verify the reward value is the expected full-success reward (1.0)
+        const [, , reward] = stores.posteriorStore.updatePosterior.mock.calls[0];
+        expect(reward).toBe(1.0);
+    });
+});

package/dist/src/routing/observation-store.d.ts

@@ -0,0 +1,40 @@
+import type { AgentProviderName } from '../providers/types.js';
+import type { AgentWorkType } from '../orchestrator/work-types.js';
+import type { RoutingObservation } from './types.js';
+/**
+ * Observation Store Interface
+ *
+ * Append-only log of routing observations for the MAB router.
+ * Implementations may use Redis Streams, SQLite, or in-memory storage.
+ * Core defines only the interface — concrete stores live in server or plugin packages.
+ */
+export interface ObservationStore {
+    /**
+     * Append a single observation to the store.
+     */
+    recordObservation(obs: RoutingObservation): Promise<void>;
+    /**
+     * Query observations with optional filters.
+     *
+     * @param opts.provider  - Filter by agent provider
+     * @param opts.workType  - Filter by work type
+     * @param opts.limit     - Maximum number of observations to return
+     * @param opts.since     - Only return observations with timestamp >= since (epoch ms)
+     */
+    getObservations(opts: {
+        provider?: AgentProviderName;
+        workType?: AgentWorkType;
+        limit?: number;
+        since?: number;
+    }): Promise<RoutingObservation[]>;
+    /**
+     * Get the most recent observations for a specific provider + work type pair.
+     * Results are returned newest-first, up to `windowSize` entries.
+     *
+     * @param provider   - Agent provider name
+     * @param workType   - Agent work type
+     * @param windowSize - Maximum number of recent observations to return
+     */
+    getRecentObservations(provider: AgentProviderName, workType: AgentWorkType, windowSize: number): Promise<RoutingObservation[]>;
+}
+//# sourceMappingURL=observation-store.d.ts.map

package/dist/src/routing/observation-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observation-store.d.ts","sourceRoot":"","sources":["../../../src/routing/observation-store.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,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,iBAAiB,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEzD;;;;;;;OAOG;IACH,eAAe,CAAC,IAAI,EAAE;QACpB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;QAC5B,QAAQ,CAAC,EAAE,aAAa,CAAA;QACxB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAA;IAEjC;;;;;;;OAOG;IACH,qBAAqB,CACnB,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAA;CACjC"}

package/dist/src/routing/observation-store.js

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

package/dist/src/routing/observation-store.test.d.ts

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

package/dist/src/routing/observation-store.test.d.ts.map

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

package/dist/src/routing/observation-store.test.js

@@ -0,0 +1,138 @@
+import { describe, it, expect } from 'vitest';
+/**
+ * Type-level tests for ObservationStore interface.
+ *
+ * These verify that the interface is well-defined and that a conforming
+ * implementation can be constructed without type errors.
+ */
+function makeObservation(overrides) {
+    return {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        provider: 'claude',
+        workType: 'development',
+        issueIdentifier: 'SUP-100',
+        sessionId: 'session-abc-123',
+        reward: 0.85,
+        taskCompleted: true,
+        prCreated: true,
+        qaResult: 'passed',
+        totalCostUsd: 0.42,
+        wallClockMs: 120000,
+        timestamp: 1700000000,
+        confidence: 0.9,
+        ...overrides,
+    };
+}
+/** In-memory ObservationStore for type conformance testing */
+function createInMemoryStore() {
+    const observations = [];
+    return {
+        async recordObservation(obs) {
+            observations.push(obs);
+        },
+        async getObservations(opts) {
+            let result = [...observations];
+            if (opts.provider) {
+                result = result.filter((o) => o.provider === opts.provider);
+            }
+            if (opts.workType) {
+                result = result.filter((o) => o.workType === opts.workType);
+            }
+            if (opts.since) {
+                result = result.filter((o) => o.timestamp >= opts.since);
+            }
+            if (opts.limit) {
+                result = result.slice(0, opts.limit);
+            }
+            return result;
+        },
+        async getRecentObservations(provider, workType, windowSize) {
+            return observations
+                .filter((o) => o.provider === provider && o.workType === workType)
+                .reverse()
+                .slice(0, windowSize);
+        },
+    };
+}
+describe('ObservationStore interface', () => {
+    it('accepts a conforming in-memory implementation', () => {
+        const store = createInMemoryStore();
+        expect(store).toBeDefined();
+        expect(typeof store.recordObservation).toBe('function');
+        expect(typeof store.getObservations).toBe('function');
+        expect(typeof store.getRecentObservations).toBe('function');
+    });
+    it('recordObservation stores an observation', async () => {
+        const store = createInMemoryStore();
+        const obs = makeObservation();
+        await store.recordObservation(obs);
+        const all = await store.getObservations({});
+        expect(all).toHaveLength(1);
+        expect(all[0]).toEqual(obs);
+    });
+    it('getObservations filters by provider', async () => {
+        const store = createInMemoryStore();
+        await store.recordObservation(makeObservation({ provider: 'claude' }));
+        await store.recordObservation(makeObservation({ provider: 'codex' }));
+        await store.recordObservation(makeObservation({ provider: 'claude' }));
+        const result = await store.getObservations({ provider: 'claude' });
+        expect(result).toHaveLength(2);
+        expect(result.every((o) => o.provider === 'claude')).toBe(true);
+    });
+    it('getObservations filters by workType', async () => {
+        const store = createInMemoryStore();
+        await store.recordObservation(makeObservation({ workType: 'development' }));
+        await store.recordObservation(makeObservation({ workType: 'qa' }));
+        const result = await store.getObservations({ workType: 'qa' });
+        expect(result).toHaveLength(1);
+        expect(result[0].workType).toBe('qa');
+    });
+    it('getObservations filters by since', async () => {
+        const store = createInMemoryStore();
+        await store.recordObservation(makeObservation({ timestamp: 1000 }));
+        await store.recordObservation(makeObservation({ timestamp: 2000 }));
+        await store.recordObservation(makeObservation({ timestamp: 3000 }));
+        const result = await store.getObservations({ since: 2000 });
+        expect(result).toHaveLength(2);
+        expect(result.every((o) => o.timestamp >= 2000)).toBe(true);
+    });
+    it('getObservations respects limit', async () => {
+        const store = createInMemoryStore();
+        for (let i = 0; i < 10; i++) {
+            await store.recordObservation(makeObservation({ timestamp: i }));
+        }
+        const result = await store.getObservations({ limit: 3 });
+        expect(result).toHaveLength(3);
+    });
+    it('getRecentObservations returns newest-first for a provider+workType pair', async () => {
+        const store = createInMemoryStore();
+        await store.recordObservation(makeObservation({ provider: 'claude', workType: 'development', timestamp: 1000 }));
+        await store.recordObservation(makeObservation({ provider: 'codex', workType: 'development', timestamp: 2000 }));
+        await store.recordObservation(makeObservation({ provider: 'claude', workType: 'development', timestamp: 3000 }));
+        await store.recordObservation(makeObservation({ provider: 'claude', workType: 'qa', timestamp: 4000 }));
+        const result = await store.getRecentObservations('claude', 'development', 10);
+        expect(result).toHaveLength(2);
+        // Newest first
+        expect(result[0].timestamp).toBe(3000);
+        expect(result[1].timestamp).toBe(1000);
+    });
+    it('getRecentObservations respects windowSize', async () => {
+        const store = createInMemoryStore();
+        for (let i = 0; i < 10; i++) {
+            await store.recordObservation(makeObservation({ provider: 'amp', workType: 'research', timestamp: i }));
+        }
+        const result = await store.getRecentObservations('amp', 'research', 3);
+        expect(result).toHaveLength(3);
+    });
+    it('getObservations returns empty array when no observations match', async () => {
+        const store = createInMemoryStore();
+        await store.recordObservation(makeObservation({ provider: 'claude' }));
+        const result = await store.getObservations({ provider: 'codex' });
+        expect(result).toEqual([]);
+    });
+    it('getRecentObservations returns empty array when no observations match', async () => {
+        const store = createInMemoryStore();
+        const result = await store.getRecentObservations('claude', 'development', 10);
+        expect(result).toEqual([]);
+    });
+});

package/dist/src/routing/posterior-store.d.ts

@@ -0,0 +1,12 @@
+import type { AgentProviderName } from '../providers/types.js';
+import type { AgentWorkType } from '../orchestrator/work-types.js';
+import type { RoutingPosterior } from './types.js';
+export interface PosteriorStore {
+    getPosterior(provider: AgentProviderName, workType: AgentWorkType): Promise<RoutingPosterior>;
+    updatePosterior(provider: AgentProviderName, workType: AgentWorkType, reward: number): Promise<RoutingPosterior>;
+    getAllPosteriors(): Promise<RoutingPosterior[]>;
+    resetPosterior(provider: AgentProviderName, workType: AgentWorkType): Promise<void>;
+}
+/** Default Beta(1,1) prior -- uniform distribution (optimistic cold start) */
+export declare function defaultPosterior(provider: AgentProviderName, workType: AgentWorkType): RoutingPosterior;
+//# sourceMappingURL=posterior-store.d.ts.map

package/dist/src/routing/posterior-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posterior-store.d.ts","sourceRoot":"","sources":["../../../src/routing/posterior-store.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,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,MAAM,WAAW,cAAc;IAC7B,YAAY,CAAC,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAC7F,eAAe,CAAC,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;IAChH,gBAAgB,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAA;IAC/C,cAAc,CAAC,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACpF;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,QAAQ,EAAE,aAAa,GAAG,gBAAgB,CAWvG"}

package/dist/src/routing/posterior-store.js

@@ -0,0 +1,13 @@
+/** Default Beta(1,1) prior -- uniform distribution (optimistic cold start) */
+export function defaultPosterior(provider, workType) {
+    return {
+        provider,
+        workType,
+        alpha: 1,
+        beta: 1,
+        totalObservations: 0,
+        avgReward: 0,
+        avgCostUsd: 0,
+        lastUpdated: Date.now(),
+    };
+}

package/dist/src/routing/posterior-store.test.d.ts

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

package/dist/src/routing/posterior-store.test.d.ts.map

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

package/dist/src/routing/posterior-store.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { defaultPosterior } from './posterior-store.js';
+describe('defaultPosterior', () => {
+    it('returns Beta(1,1) with correct provider and workType', () => {
+        const posterior = defaultPosterior('claude', 'development');
+        expect(posterior.provider).toBe('claude');
+        expect(posterior.workType).toBe('development');
+        expect(posterior.alpha).toBe(1);
+        expect(posterior.beta).toBe(1);
+    });
+    it('has totalObservations of 0', () => {
+        const posterior = defaultPosterior('codex', 'qa');
+        expect(posterior.totalObservations).toBe(0);
+    });
+    it('has avgReward of 0', () => {
+        const posterior = defaultPosterior('amp', 'research');
+        expect(posterior.avgReward).toBe(0);
+    });
+    it('has avgCostUsd of 0', () => {
+        const posterior = defaultPosterior('claude', 'inflight');
+        expect(posterior.avgCostUsd).toBe(0);
+    });
+    it('has a reasonable lastUpdated timestamp', () => {
+        const before = Date.now();
+        const posterior = defaultPosterior('claude', 'development');
+        const after = Date.now();
+        expect(posterior.lastUpdated).toBeGreaterThanOrEqual(before);
+        expect(posterior.lastUpdated).toBeLessThanOrEqual(after);
+    });
+    it('works with coordination work types', () => {
+        const posterior = defaultPosterior('amp', 'qa-coordination');
+        expect(posterior.provider).toBe('amp');
+        expect(posterior.workType).toBe('qa-coordination');
+        expect(posterior.alpha).toBe(1);
+        expect(posterior.beta).toBe(1);
+    });
+});

package/dist/src/routing/reward.d.ts

@@ -0,0 +1,16 @@
+import type { AgentProcess } from '../orchestrator/types.js';
+export declare const MAX_EXPECTED_COST = 5;
+export interface RoutingReward {
+    taskCompleted: boolean;
+    prCreated: boolean;
+    qaResult: 'passed' | 'failed' | 'unknown';
+    totalCostUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    wallClockTimeMs: number;
+    requiredRefinements: number;
+    humanEscalations: number;
+}
+export declare function computeReward(outcome: RoutingReward): number;
+export declare function extractRewardFromProcess(process: AgentProcess): RoutingReward;
+//# sourceMappingURL=reward.d.ts.map

package/dist/src/routing/reward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward.d.ts","sourceRoot":"","sources":["../../../src/routing/reward.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,eAAO,MAAM,iBAAiB,IAAM,CAAA;AAEpC,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,OAAO,CAAA;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;IACzC,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,EAAE,MAAM,CAAA;IACvB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAS5D;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAe7E"}

package/dist/src/routing/reward.js

@@ -0,0 +1,29 @@
+export const MAX_EXPECTED_COST = 5.0; // USD
+export function computeReward(outcome) {
+    let reward = 0;
+    if (outcome.taskCompleted)
+        reward += 0.5;
+    if (outcome.prCreated)
+        reward += 0.2;
+    if (outcome.qaResult === 'passed')
+        reward += 0.3;
+    // Cost penalty (normalized)
+    const costPenalty = Math.min(outcome.totalCostUsd / MAX_EXPECTED_COST, 1);
+    reward -= 0.1 * costPenalty;
+    return Math.max(0, Math.min(1, reward));
+}
+export function extractRewardFromProcess(process) {
+    return {
+        taskCompleted: process.status === 'completed',
+        prCreated: process.pullRequestUrl !== undefined,
+        qaResult: process.workResult ?? 'unknown',
+        totalCostUsd: process.totalCostUsd ?? 0,
+        inputTokens: process.inputTokens ?? 0,
+        outputTokens: process.outputTokens ?? 0,
+        wallClockTimeMs: process.completedAt && process.startedAt
+            ? process.completedAt.getTime() - process.startedAt.getTime()
+            : 0,
+        requiredRefinements: 0,
+        humanEscalations: 0,
+    };
+}

package/dist/src/routing/reward.test.d.ts

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

package/dist/src/routing/reward.test.d.ts.map

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