@elizaos/training 2.0.0-alpha.21 → 2.0.0-alpha.22

package/dist/training/TrajectoryRecorder.js

@@ -0,0 +1,281 @@
+/**
+ * TrajectoryRecorder
+ *
+ * Records agent decisions with full context for GRPO training.
+ * Captures environment state, LLM calls, actions, and rewards.
+ *
+ * @packageDocumentation
+ */
+import { getLlmLogAdapter, getTrainingDataAdapter } from "../adapter";
+import { logger } from "../utils/logger";
+import { generateSnowflakeId } from "../utils/snowflake";
+import { getCurrentWindowId } from "./window-utils";
+import * as fs from "node:fs";
+import * as path from "node:path";
+// ─── Simulation mode flag ────────────────────────────────────────────
+// Replaces the `isSimulationMode` import from `@elizaos/db`.
+// Set via `setSimulationMode(true)` before recording trajectories in
+// simulation/benchmark contexts.
+let _simulationMode = false;
+/** Enable or disable simulation mode for trajectory recording. */
+export function setSimulationMode(enabled) {
+    _simulationMode = enabled;
+}
+/** Check whether simulation mode is active. */
+export function isSimulationMode() {
+    return _simulationMode;
+}
+/**
+ * Records agent trajectories for RL training.
+ */
+export class TrajectoryRecorder {
+    activeTrajectories = new Map();
+    /**
+     * Start recording a new trajectory.
+     * @param options - Configuration for the trajectory
+     * @returns The unique trajectory ID
+     */
+    async startTrajectory(options) {
+        const trajectoryId = await generateSnowflakeId();
+        const windowId = options.windowId || getCurrentWindowId();
+        this.activeTrajectories.set(trajectoryId, {
+            trajectoryId,
+            agentId: options.agentId,
+            archetype: options.archetype,
+            scenarioId: options.scenarioId || windowId,
+            startTime: Date.now(),
+            steps: [],
+        });
+        logger.info("Started trajectory recording", {
+            trajectoryId,
+            agentId: options.agentId,
+            archetype: options.archetype,
+            scenarioId: options.scenarioId,
+            windowId,
+        });
+        return trajectoryId;
+    }
+    /**
+     * Start a new step in the trajectory.
+     * @param trajectoryId - The trajectory ID
+     * @param environmentState - Current environment state
+     * @throws Error if trajectory not found
+     */
+    startStep(trajectoryId, environmentState) {
+        const traj = this.activeTrajectories.get(trajectoryId);
+        if (!traj) {
+            throw new Error(`Trajectory not found: ${trajectoryId}`);
+        }
+        traj.currentStep = {
+            stepNumber: traj.steps.length,
+            timestamp: Date.now(),
+            environmentState,
+            providerAccesses: [],
+            llmCalls: [],
+            reward: 0,
+        };
+    }
+    /**
+     * Log a provider access in the current step.
+     * @param trajectoryId - The trajectory ID
+     * @param access - Provider access details
+     * @throws Error if no current step exists
+     */
+    logProviderAccess(trajectoryId, access) {
+        const traj = this.activeTrajectories.get(trajectoryId);
+        if (!traj?.currentStep) {
+            throw new Error(`No current step for trajectory: ${trajectoryId}`);
+        }
+        traj.currentStep.providerAccesses = traj.currentStep.providerAccesses || [];
+        traj.currentStep.providerAccesses.push(access);
+    }
+    /**
+     * Log an LLM call in the current step.
+     * @param trajectoryId - The trajectory ID
+     * @param llmCall - LLM call details
+     * @throws Error if no current step exists
+     */
+    logLLMCall(trajectoryId, llmCall) {
+        const traj = this.activeTrajectories.get(trajectoryId);
+        if (!traj?.currentStep) {
+            throw new Error(`No current step for trajectory: ${trajectoryId}`);
+        }
+        traj.currentStep.llmCalls = traj.currentStep.llmCalls || [];
+        traj.currentStep.llmCalls.push(llmCall);
+    }
+    /**
+     * Complete the current step with an action.
+     * @param trajectoryId - The trajectory ID
+     * @param action - The action taken
+     * @param reward - Immediate reward for the step
+     * @throws Error if no current step exists
+     */
+    completeStep(trajectoryId, action, reward = 0) {
+        const traj = this.activeTrajectories.get(trajectoryId);
+        if (!traj?.currentStep) {
+            throw new Error(`No current step for trajectory: ${trajectoryId}`);
+        }
+        const stepNumber = traj.currentStep.stepNumber;
+        const timestamp = traj.currentStep.timestamp;
+        const environmentState = traj.currentStep.environmentState;
+        if (stepNumber === undefined ||
+            timestamp === undefined ||
+            environmentState === undefined) {
+            throw new Error(`Current step incomplete for trajectory: ${trajectoryId}`);
+        }
+        const completeStep = {
+            stepNumber,
+            timestamp,
+            environmentState,
+            providerAccesses: traj.currentStep.providerAccesses || [],
+            llmCalls: traj.currentStep.llmCalls || [],
+            action,
+            reward,
+        };
+        traj.steps.push(completeStep);
+        traj.currentStep = undefined;
+    }
+    /**
+     * End trajectory and save to database.
+     * @param trajectoryId - The trajectory ID
+     * @param options - End options including final metrics
+     * @throws Error if trajectory not found
+     */
+    async endTrajectory(trajectoryId, options = {}) {
+        const traj = this.activeTrajectories.get(trajectoryId);
+        if (!traj) {
+            throw new Error(`Trajectory not found: ${trajectoryId}`);
+        }
+        const endTime = Date.now();
+        const durationMs = endTime - traj.startTime;
+        const totalReward = traj.steps.reduce((sum, step) => sum + step.reward, 0);
+        const windowId = options.windowId || getCurrentWindowId();
+        // Calculate metrics
+        const tradesExecuted = traj.steps.filter((s) => s.action.actionType.includes("BUY") ||
+            s.action.actionType.includes("SELL")).length;
+        const postsCreated = traj.steps.filter((s) => s.action.actionType.includes("POST")).length;
+        const errorCount = traj.steps.filter((s) => !s.action.success).length;
+        const finalStatus = errorCount > 0 ? "completed_with_errors" : "completed";
+        // 1. Prepare the standard data object (Used for both JSON and DB)
+        const trajectoryData = {
+            id: await generateSnowflakeId(),
+            trajectoryId,
+            agentId: traj.agentId,
+            archetype: traj.archetype ?? null,
+            startTime: new Date(traj.startTime),
+            endTime: new Date(endTime),
+            durationMs,
+            scenarioId: traj.scenarioId || windowId,
+            episodeId: traj.scenarioId ? `${traj.scenarioId}-${Date.now()}` : null,
+            windowId,
+            windowHours: 1,
+            batchId: null,
+            stepsJson: JSON.stringify(traj.steps),
+            rewardComponentsJson: JSON.stringify({ environmentReward: totalReward }),
+            metricsJson: JSON.stringify({
+                episodeLength: traj.steps.length,
+                finalStatus,
+                finalBalance: options.finalBalance,
+                finalPnL: options.finalPnL,
+                tradesExecuted,
+                postsCreated,
+                errorCount,
+            }),
+            metadataJson: JSON.stringify({
+                isTrainingData: true,
+                gameKnowledge: options.gameKnowledge || {},
+            }),
+            totalReward,
+            episodeLength: traj.steps.length,
+            finalStatus,
+            finalBalance: options.finalBalance ?? null,
+            finalPnL: options.finalPnL ?? null,
+            tradesExecuted: tradesExecuted ?? null,
+            postsCreated: postsCreated ?? null,
+            aiJudgeReward: null,
+            aiJudgeReasoning: null,
+            judgedAt: null,
+            isTrainingData: true,
+            isEvaluation: false,
+            usedInTraining: false,
+            trainedInBatch: null,
+        };
+        // Simulation Mode Bypass
+        if (isSimulationMode()) {
+            const outputDir = "./training-data-output/trajectories";
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            const fullData = {
+                trajectory: trajectoryData,
+                llmCalls: traj.steps.flatMap((step) => step.llmCalls.map((call, idx) => ({
+                    stepNumber: step.stepNumber,
+                    callIndex: idx,
+                    ...call,
+                }))),
+            };
+            const filePath = path.join(outputDir, `${trajectoryId}.json`);
+            fs.writeFileSync(filePath, JSON.stringify(fullData, null, 2));
+            logger.info("Saved trajectory to JSON (Simulation Mode)", { trajectoryId, path: filePath }, "TrajectoryRecorder");
+            this.activeTrajectories.delete(trajectoryId);
+            return;
+        }
+        const adapter = getTrainingDataAdapter();
+        await adapter.insertTrajectory(trajectoryData);
+        // Save LLM calls via adapter (if LLM log adapter is registered)
+        const llmLogAdapter = getLlmLogAdapter();
+        if (llmLogAdapter) {
+            for (const step of traj.steps) {
+                for (const llmCall of step.llmCalls) {
+                    await llmLogAdapter.insertLLMCallLog({
+                        id: await generateSnowflakeId(),
+                        trajectoryId,
+                        stepId: `${trajectoryId}-step-${step.stepNumber}`,
+                        callId: `${trajectoryId}-call-${step.stepNumber}-${step.llmCalls.indexOf(llmCall)}`,
+                        timestamp: new Date(step.timestamp),
+                        latencyMs: llmCall.latencyMs ?? null,
+                        model: llmCall.model,
+                        purpose: llmCall.purpose,
+                        actionType: llmCall.actionType ?? null,
+                        systemPrompt: llmCall.systemPrompt,
+                        userPrompt: llmCall.userPrompt,
+                        response: llmCall.response,
+                    });
+                }
+            }
+        }
+        logger.info("Trajectory saved to database", {
+            trajectoryId,
+            archetype: traj.archetype,
+            steps: traj.steps.length,
+            reward: totalReward,
+            duration: durationMs,
+        });
+        this.activeTrajectories.delete(trajectoryId);
+    }
+    /**
+     * Get an active trajectory by ID.
+     * @param trajectoryId - The trajectory ID
+     * @returns The active trajectory or undefined
+     */
+    getActiveTrajectory(trajectoryId) {
+        return this.activeTrajectories.get(trajectoryId);
+    }
+    /**
+     * Check if a trajectory is active.
+     * @param trajectoryId - The trajectory ID
+     * @returns True if trajectory is active
+     */
+    isActive(trajectoryId) {
+        return this.activeTrajectories.has(trajectoryId);
+    }
+    /**
+     * Get count of active trajectories.
+     * @returns Number of active trajectories
+     */
+    getActiveCount() {
+        return this.activeTrajectories.size;
+    }
+}
+/** Singleton instance */
+export const trajectoryRecorder = new TrajectoryRecorder();

package/dist/training/__tests__/TrajectoryRecorder.test.js

@@ -0,0 +1,363 @@
+/**
+ * TrajectoryRecorder Tests
+ *
+ * REAL tests that exercise the actual TrajectoryRecorder class.
+ * Uses simulation mode to avoid database dependency.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { setSimulationMode, TrajectoryRecorder } from "../TrajectoryRecorder";
+// =============================================================================
+// Test Setup
+// =============================================================================
+const TEST_OUTPUT_DIR = "./training-data-output/trajectories";
+describe("TrajectoryRecorder - Real Class Tests", () => {
+    let recorder;
+    beforeEach(() => {
+        setSimulationMode(true);
+        recorder = new TrajectoryRecorder();
+        // Clean up test output
+        if (fs.existsSync(TEST_OUTPUT_DIR)) {
+            const files = fs.readdirSync(TEST_OUTPUT_DIR);
+            for (const file of files) {
+                if (file.startsWith("test-")) {
+                    fs.unlinkSync(path.join(TEST_OUTPUT_DIR, file));
+                }
+            }
+        }
+    });
+    afterEach(() => {
+        setSimulationMode(false);
+        // Cleanup after each test
+        if (fs.existsSync(TEST_OUTPUT_DIR)) {
+            const files = fs.readdirSync(TEST_OUTPUT_DIR);
+            for (const file of files) {
+                if (file.includes("test-agent")) {
+                    try {
+                        fs.unlinkSync(path.join(TEST_OUTPUT_DIR, file));
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            }
+        }
+    });
+    // ===========================================================================
+    // Lifecycle Tests
+    // ===========================================================================
+    test("startTrajectory creates a new active trajectory", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent-1",
+            archetype: "trader",
+        });
+        expect(trajectoryId).toBeDefined();
+        expect(typeof trajectoryId).toBe("string");
+        expect(trajectoryId.length).toBeGreaterThan(10);
+        expect(recorder.isActive(trajectoryId)).toBe(true);
+        expect(recorder.getActiveCount()).toBe(1);
+    });
+    test("multiple trajectories can be active simultaneously", async () => {
+        const id1 = await recorder.startTrajectory({ agentId: "test-agent-1" });
+        const id2 = await recorder.startTrajectory({ agentId: "test-agent-2" });
+        const id3 = await recorder.startTrajectory({ agentId: "test-agent-3" });
+        expect(recorder.getActiveCount()).toBe(3);
+        expect(recorder.isActive(id1)).toBe(true);
+        expect(recorder.isActive(id2)).toBe(true);
+        expect(recorder.isActive(id3)).toBe(true);
+        expect(id1).not.toBe(id2);
+        expect(id2).not.toBe(id3);
+    });
+    test("getActiveTrajectory returns correct trajectory", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent-x",
+            archetype: "degen",
+            scenarioId: "test-scenario",
+        });
+        const active = recorder.getActiveTrajectory(trajectoryId);
+        expect(active).toBeDefined();
+        expect(active?.agentId).toBe("test-agent-x");
+        expect(active?.archetype).toBe("degen");
+        expect(active?.scenarioId).toBe("test-scenario");
+        expect(active?.steps).toHaveLength(0);
+    });
+    test("getActiveTrajectory returns undefined for non-existent id", () => {
+        const result = recorder.getActiveTrajectory("non-existent-id");
+        expect(result).toBeUndefined();
+    });
+    // ===========================================================================
+    // Step Recording Tests
+    // ===========================================================================
+    test("startStep initializes current step with environment state", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        const envState = {
+            agentBalance: 10000,
+            agentPnL: 0,
+            openPositions: 0,
+        };
+        recorder.startStep(trajectoryId, envState);
+        const active = recorder.getActiveTrajectory(trajectoryId);
+        expect(active?.currentStep).toBeDefined();
+        expect(active?.currentStep?.environmentState).toEqual(envState);
+        expect(active?.currentStep?.stepNumber).toBe(0);
+    });
+    test("startStep throws for non-existent trajectory", () => {
+        expect(() => {
+            recorder.startStep("fake-id", {
+                agentBalance: 0,
+                agentPnL: 0,
+                openPositions: 0,
+            });
+        }).toThrow("Trajectory not found: fake-id");
+    });
+    test("logProviderAccess adds provider data to current step", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        recorder.startStep(trajectoryId, {
+            agentBalance: 1000,
+            agentPnL: 0,
+            openPositions: 0,
+        });
+        recorder.logProviderAccess(trajectoryId, {
+            providerName: "market-data",
+            data: { ticker: "BTCAI", price: 50000 },
+            purpose: "price lookup",
+        });
+        const active = recorder.getActiveTrajectory(trajectoryId);
+        expect(active?.currentStep?.providerAccesses).toHaveLength(1);
+        expect(active?.currentStep?.providerAccesses?.[0]?.providerName).toBe("market-data");
+    });
+    test("logProviderAccess throws when no current step", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        // Don't call startStep
+        expect(() => {
+            recorder.logProviderAccess(trajectoryId, {
+                providerName: "test",
+                data: {},
+                purpose: "test",
+            });
+        }).toThrow("No current step");
+    });
+    test("logLLMCall adds LLM call to current step", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        recorder.startStep(trajectoryId, {
+            agentBalance: 1000,
+            agentPnL: 0,
+            openPositions: 0,
+        });
+        const llmCall = {
+            model: "qwen-32b",
+            systemPrompt: "You are a trading agent",
+            userPrompt: "What should I do?",
+            response: "Buy BTCAI",
+            reasoning: "Bullish momentum",
+            temperature: 0.7,
+            maxTokens: 2000,
+            purpose: "action",
+            latencyMs: 250,
+        };
+        recorder.logLLMCall(trajectoryId, llmCall);
+        const active = recorder.getActiveTrajectory(trajectoryId);
+        expect(active?.currentStep?.llmCalls).toHaveLength(1);
+        expect(active?.currentStep?.llmCalls?.[0]?.model).toBe("qwen-32b");
+        expect(active?.currentStep?.llmCalls?.[0]?.latencyMs).toBe(250);
+    });
+    test("completeStep finalizes step and adds to trajectory", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        recorder.startStep(trajectoryId, {
+            agentBalance: 1000,
+            agentPnL: 0,
+            openPositions: 0,
+        });
+        const action = {
+            actionType: "buy",
+            parameters: { ticker: "BTCAI", amount: 100 },
+            success: true,
+        };
+        recorder.completeStep(trajectoryId, action, 0.5);
+        const active = recorder.getActiveTrajectory(trajectoryId);
+        expect(active?.steps).toHaveLength(1);
+        expect(active?.steps[0]?.action.actionType).toBe("buy");
+        expect(active?.steps[0]?.reward).toBe(0.5);
+        expect(active?.currentStep).toBeUndefined();
+    });
+    test("multiple steps increment step number correctly", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        for (let i = 0; i < 5; i++) {
+            recorder.startStep(trajectoryId, {
+                agentBalance: 1000 - i * 100,
+                agentPnL: i * 10,
+                openPositions: i,
+            });
+            recorder.completeStep(trajectoryId, { actionType: "hold", parameters: {}, success: true }, 0.1);
+        }
+        const active = recorder.getActiveTrajectory(trajectoryId);
+        expect(active?.steps).toHaveLength(5);
+        expect(active?.steps[0]?.stepNumber).toBe(0);
+        expect(active?.steps[4]?.stepNumber).toBe(4);
+    });
+    // ===========================================================================
+    // End Trajectory Tests (Simulation Mode - File Output)
+    // ===========================================================================
+    test("endTrajectory saves JSON file in simulation mode", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent-file",
+            archetype: "trader",
+        });
+        // Add a step
+        recorder.startStep(trajectoryId, {
+            agentBalance: 10000,
+            agentPnL: 0,
+            openPositions: 0,
+        });
+        recorder.logLLMCall(trajectoryId, {
+            model: "test-model",
+            systemPrompt: "system",
+            userPrompt: "user",
+            response: "response",
+            temperature: 0.5,
+            maxTokens: 100,
+            purpose: "action",
+        });
+        recorder.completeStep(trajectoryId, { actionType: "buy", parameters: { ticker: "BTCAI" }, success: true }, 1.0);
+        await recorder.endTrajectory(trajectoryId, {
+            finalBalance: 10500,
+            finalPnL: 500,
+        });
+        // Verify file was created
+        const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
+        expect(fs.existsSync(filePath)).toBe(true);
+        // Verify file contents
+        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        expect(content.trajectory.agentId).toBe("test-agent-file");
+        expect(content.trajectory.archetype).toBe("trader");
+        expect(content.trajectory.episodeLength).toBe(1);
+        expect(content.trajectory.finalBalance).toBe(10500);
+        expect(content.trajectory.finalPnL).toBe(500);
+        expect(content.llmCalls).toHaveLength(1);
+        // Cleanup
+        fs.unlinkSync(filePath);
+    });
+    test("endTrajectory removes trajectory from active map", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        expect(recorder.isActive(trajectoryId)).toBe(true);
+        await recorder.endTrajectory(trajectoryId);
+        expect(recorder.isActive(trajectoryId)).toBe(false);
+        expect(recorder.getActiveCount()).toBe(0);
+    });
+    test("endTrajectory throws for non-existent trajectory", async () => {
+        await expect(recorder.endTrajectory("fake-id")).rejects.toThrow("Trajectory not found: fake-id");
+    });
+    test("endTrajectory calculates metrics correctly", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        // Add buy action
+        recorder.startStep(trajectoryId, {
+            agentBalance: 10000,
+            agentPnL: 0,
+            openPositions: 0,
+        });
+        recorder.completeStep(trajectoryId, { actionType: "BUY_YES", parameters: {}, success: true }, 1.0);
+        // Add sell action
+        recorder.startStep(trajectoryId, {
+            agentBalance: 9000,
+            agentPnL: 100,
+            openPositions: 1,
+        });
+        recorder.completeStep(trajectoryId, { actionType: "SELL", parameters: {}, success: true }, 0.5);
+        // Add failed action
+        recorder.startStep(trajectoryId, {
+            agentBalance: 9500,
+            agentPnL: 150,
+            openPositions: 0,
+        });
+        recorder.completeStep(trajectoryId, {
+            actionType: "BUY_NO",
+            parameters: {},
+            success: false,
+            error: "Insufficient funds",
+        }, -0.5);
+        await recorder.endTrajectory(trajectoryId);
+        // Check that file was written with correct metrics
+        const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
+        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        expect(content.trajectory.episodeLength).toBe(3);
+        expect(content.trajectory.tradesExecuted).toBe(3); // BUY_YES, SELL, BUY_NO
+        expect(content.trajectory.totalReward).toBe(1.0); // 1.0 + 0.5 + (-0.5)
+        expect(content.trajectory.finalStatus).toBe("completed_with_errors");
+        fs.unlinkSync(filePath);
+    });
+    // ===========================================================================
+    // Edge Cases
+    // ===========================================================================
+    test("handles trajectory with zero steps", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        await recorder.endTrajectory(trajectoryId);
+        const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
+        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        expect(content.trajectory.episodeLength).toBe(0);
+        expect(content.trajectory.totalReward).toBe(0);
+        expect(content.llmCalls).toHaveLength(0);
+        fs.unlinkSync(filePath);
+    });
+    test("handles very long prompts in LLM calls", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        recorder.startStep(trajectoryId, {
+            agentBalance: 1000,
+            agentPnL: 0,
+            openPositions: 0,
+        });
+        const longPrompt = "A".repeat(50000); // 50k characters
+        recorder.logLLMCall(trajectoryId, {
+            model: "test",
+            systemPrompt: longPrompt,
+            userPrompt: longPrompt,
+            response: longPrompt,
+            temperature: 0.5,
+            maxTokens: 100,
+            purpose: "action",
+        });
+        recorder.completeStep(trajectoryId, { actionType: "hold", parameters: {}, success: true }, 0);
+        await recorder.endTrajectory(trajectoryId);
+        const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
+        expect(fs.existsSync(filePath)).toBe(true);
+        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        expect(content.llmCalls[0].systemPrompt.length).toBe(50000);
+        fs.unlinkSync(filePath);
+    });
+    test("handles negative rewards correctly", async () => {
+        const trajectoryId = await recorder.startTrajectory({
+            agentId: "test-agent",
+        });
+        recorder.startStep(trajectoryId, {
+            agentBalance: 1000,
+            agentPnL: 0,
+            openPositions: 0,
+        });
+        recorder.completeStep(trajectoryId, { actionType: "buy", parameters: {}, success: false, error: "Bad trade" }, -5.0);
+        await recorder.endTrajectory(trajectoryId);
+        const filePath = path.join(TEST_OUTPUT_DIR, `${trajectoryId}.json`);
+        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        expect(content.trajectory.totalReward).toBe(-5.0);
+        fs.unlinkSync(filePath);
+    });
+});

package/dist/training/index.js

@@ -0,0 +1,30 @@
+/**
+ * Training Module
+ *
+ * Core training pipeline services for RL model development.
+ */
+export { AutomationPipeline, automationPipeline } from "./AutomationPipeline";
+export { BenchmarkService, benchmarkService } from "./BenchmarkService";
+export { ConfigValidator } from "./ConfigValidator";
+export { logRLConfigOnStartup } from "./logRLConfig";
+export { MarketOutcomesTracker } from "./MarketOutcomesTracker";
+export { ModelDeployer, modelDeployer } from "./ModelDeployer";
+// Model fetching
+export { getLatestRLModel } from "./ModelFetcher";
+export { ModelSelectionService, modelSelectionService, } from "./ModelSelectionService";
+export { ModelUsageVerifier } from "./ModelUsageVerifier";
+export { createMultiModelOrchestrator, MultiModelOrchestrator, } from "./MultiModelOrchestrator";
+export { benchmarkAndMaybeDeployModel, checkTrainingReadiness, deployModelVersion, getAutomationPipelineStatus, getNextTrainingModelSelection, monitorTrainingJob, rollbackModelVersion, triggerTraining, } from "./pipeline";
+export { RewardBackpropagationService, rewardBackpropagationService, } from "./RewardBackpropagationService";
+export { clearArchetypeModels, getAllArchetypeModels, getAvailableModelTiers, getModelForArchetype, getModelForTier, getModelTierForVram, getMultiModelConfig, getQuantizedModelName, getRLModelConfig, getVramRequirement, hasArchetypeModel, isRLModelAvailable, isTierAvailable, logRLModelConfig, MODEL_TIERS, 
+// Archetype model management
+registerArchetypeModel, } from "./RLModelConfig";
+export { RulerScoringService, rulerScoringService, } from "./RulerScoringService";
+// Storage services
+export * from "./storage";
+export { TrainingMonitor, trainingMonitor } from "./TrainingMonitor";
+export { TrajectoryRecorder, trajectoryRecorder } from "./TrajectoryRecorder";
+// Types
+export * from "./types";
+// Window utilities
+export { generateWindowIds, getCurrentWindowId, getPreviousWindowId, getWindowIdForTimestamp, getWindowRange, isTimestampInWindow, isWindowComplete, parseWindowId, } from "./window-utils";