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

package/dist/scoring/JudgePromptBuilder.js

@@ -0,0 +1,401 @@
+/**
+ * JudgePromptBuilder
+ *
+ * Builds LLM judge prompts with trajectory metrics context and archetype-specific rubrics.
+ * Metrics are included as CONTEXT for the judge, not weighted directly.
+ *
+ * @packageDocumentation
+ */
+import { getMetricsSummary } from "../metrics/types";
+import { getPriorityMetrics, getRubric } from "../rubrics";
+const DEFAULT_OPTIONS = {
+    includeActionDetails: false,
+    maxActionsToShow: 20,
+    includeKeyDecisions: true,
+};
+/**
+ * Builds prompts for LLM-as-judge scoring.
+ */
+export class JudgePromptBuilder {
+    /**
+     * Build prompt for single trajectory scoring.
+     * @param trajectory - Trajectory context
+     * @param options - Prompt options
+     * @returns System and user prompts
+     */
+    buildSinglePrompt(trajectory, options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        const archetype = trajectory.archetype || "default";
+        const rubric = getRubric(archetype);
+        const priorityMetrics = getPriorityMetrics(archetype);
+        const system = this.buildSystemPrompt(archetype, rubric);
+        const user = this.buildUserPrompt(trajectory, priorityMetrics, opts);
+        return { system, user };
+    }
+    /**
+     * Build a judge prompt for comparing multiple trajectories (RULER style)
+     */
+    buildComparisonPrompt(trajectories, scenarioId, options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        // Get archetype from first trajectory (assume all same archetype for comparison)
+        const archetype = trajectories[0]?.archetype || "default";
+        const rubric = getRubric(archetype);
+        const priorityMetrics = getPriorityMetrics(archetype);
+        const system = this.buildComparisonSystemPrompt(archetype, rubric);
+        const user = this.buildComparisonUserPrompt(trajectories, scenarioId, priorityMetrics, opts);
+        return { system, user };
+    }
+    /**
+     * Build system prompt for single trajectory evaluation
+     */
+    buildSystemPrompt(archetype, rubric) {
+        return `You are an expert evaluator of AI agent performance in prediction market simulations.
+
+You are evaluating an agent with the "${archetype}" archetype. This archetype has specific goals and behaviors that should be evaluated differently than a generic agent.
+
+${rubric}
+
+Your task is to score this trajectory on a scale of 0.0 to 1.0 based on how well the agent embodied the "${archetype}" archetype's values and achieved its goals.
+
+IMPORTANT: The metrics provided are CONTEXT to inform your judgment. Use them to understand what happened, but make a holistic evaluation based on the rubric - don't just calculate a weighted average of metrics.`;
+    }
+    /**
+     * Build system prompt for RULER comparison
+     */
+    buildComparisonSystemPrompt(archetype, rubric) {
+        return `You are an expert evaluator of AI agent performance. All trajectories below were given the same scenario and are from "${archetype}" archetype agents.
+
+Your job is to compare them RELATIVE to each other and assign scores from 0 to 1 based on how well each trajectory achieved the archetype's goals.
+
+${rubric}
+
+IMPORTANT RULER PRINCIPLES:
+- A trajectory that achieves its archetype's goals should score significantly higher than one that doesn't
+- A trajectory that achieves goals more efficiently should score higher
+- If one trajectory is only slightly better, score differences should be small
+- If one is significantly better, score differences should be large
+- You may give partial credit for progress towards goals
+
+The metrics provided are CONTEXT to inform your judgment. Use them to understand what happened, then make holistic evaluations based on the archetype rubric.`;
+    }
+    /**
+     * Build user prompt with trajectory context and metrics
+     */
+    buildUserPrompt(trajectory, priorityMetrics, options) {
+        const parts = [];
+        // Agent info
+        parts.push(`## Agent Information`);
+        parts.push(`- Agent ID: ${trajectory.agentId}`);
+        parts.push(`- Archetype: ${trajectory.archetype || "unknown"}`);
+        parts.push(`- Episode Length: ${trajectory.episodeLength || trajectory.steps.length} ticks`);
+        parts.push("");
+        // Metrics section
+        parts.push(`## Behavioral Metrics`);
+        parts.push(this.formatMetrics(trajectory.metrics, priorityMetrics));
+        parts.push("");
+        // Action summary
+        parts.push(`## Action Summary`);
+        parts.push(this.summarizeActions(trajectory.steps));
+        parts.push("");
+        // Key decisions (if requested)
+        if (options.includeKeyDecisions) {
+            const keyDecisions = this.extractKeyDecisions(trajectory.steps);
+            if (keyDecisions) {
+                parts.push(`## Key Decisions`);
+                parts.push(keyDecisions);
+                parts.push("");
+            }
+        }
+        // Recent actions (if requested)
+        if (options.includeActionDetails) {
+            parts.push(`## Recent Actions (last ${options.maxActionsToShow})`);
+            parts.push(this.formatRecentActions(trajectory.steps, options.maxActionsToShow || 20));
+            parts.push("");
+        }
+        // Instructions
+        parts.push(`## Instructions`);
+        parts.push(`Score this trajectory on a scale of 0.0 to 1.0 based on how well it embodies the ${trajectory.archetype || "agent"} archetype's values.`);
+        parts.push("");
+        parts.push(`Respond with JSON:`);
+        parts.push(`{
+  "score": <float 0-1>,
+  "reasoning": "<2-3 sentence explanation>",
+  "strengths": ["<strength 1>", "<strength 2>"],
+  "weaknesses": ["<weakness 1>", "<weakness 2>"]
+}`);
+        return parts.join("\n");
+    }
+    /**
+     * Build user prompt for RULER comparison
+     */
+    buildComparisonUserPrompt(trajectories, scenarioId, priorityMetrics, _options) {
+        const parts = [];
+        parts.push(`## Scenario: ${scenarioId}`);
+        parts.push(`## Number of Trajectories: ${trajectories.length}`);
+        parts.push("");
+        // Performance context for all trajectories
+        parts.push(`## Trajectory Performance Context`);
+        parts.push(`(Use this to inform your scoring)`);
+        parts.push("");
+        for (let i = 0; i < trajectories.length; i++) {
+            const traj = trajectories[i];
+            if (!traj)
+                continue;
+            const trajId = `trajectory-${i + 1}`;
+            parts.push(`### ${trajId}`);
+            parts.push(`- Archetype: ${traj.archetype || "unknown"}`);
+            parts.push(`- Episode Length: ${traj.episodeLength || traj.steps.length} steps`);
+            parts.push(`- Total Reward: ${traj.totalReward?.toFixed(2) || "0.00"}`);
+            parts.push("");
+            // Key metrics for this trajectory
+            parts.push(`**Key Metrics:**`);
+            parts.push(this.formatMetrics(traj.metrics, priorityMetrics));
+            parts.push("");
+            // Action summary
+            parts.push(`**Actions:**`);
+            parts.push(this.summarizeActions(traj.steps));
+            parts.push("");
+        }
+        // Instructions
+        parts.push(`## Instructions`);
+        parts.push(`Score each trajectory from 0.0 to 1.0 RELATIVE to each other based on the archetype rubric.`);
+        parts.push("");
+        parts.push(`Respond with ONLY valid JSON:`);
+        parts.push(`{
+  "scores": [
+    {
+      "trajectory_id": "trajectory-1",
+      "explanation": "Brief explanation",
+      "score": 0.85
+    },
+    {
+      "trajectory_id": "trajectory-2",
+      "explanation": "Brief explanation",
+      "score": 0.65
+    }
+  ]
+}`);
+        return parts.join("\n");
+    }
+    /**
+     * Format metrics for prompt, highlighting priority metrics first
+     */
+    formatMetrics(metrics, priorityMetrics) {
+        const lines = [];
+        // Show priority metrics first with emphasis
+        if (priorityMetrics.length > 0) {
+            lines.push("### ⭐ KEY METRICS FOR THIS ARCHETYPE");
+            for (const metricPath of priorityMetrics.slice(0, 6)) {
+                const value = this.getMetricValue(metrics, metricPath);
+                const label = this.formatMetricLabel(metricPath);
+                lines.push(`- **${label}**: ${value}`);
+            }
+            lines.push("");
+        }
+        // Summary metrics
+        const summary = getMetricsSummary(metrics);
+        lines.push("### Performance Summary");
+        lines.push(`- Total P&L: $${summary.totalPnL.toFixed(2)}`);
+        lines.push(`- Win Rate: ${(summary.winRate * 100).toFixed(1)}%`);
+        lines.push(`- Trades Executed: ${summary.tradesExecuted}`);
+        lines.push(`- Action Success Rate: ${(summary.actionSuccessRate * 100).toFixed(1)}%`);
+        lines.push("");
+        // Social metrics
+        lines.push("### Social Activity");
+        lines.push(`- Unique Users Interacted: ${metrics.social.uniqueUsersInteracted}`);
+        lines.push(`- Group Chats Joined: ${metrics.social.groupChatsJoined}`);
+        lines.push(`- DMs Initiated: ${metrics.social.dmsInitiated}`);
+        lines.push(`- Posts Created: ${metrics.social.postsCreated}`);
+        lines.push(`- Comments Made: ${metrics.social.commentsMade}`);
+        lines.push(`- Social to Trade Ratio: ${metrics.behavior.socialToTradeRatio.toFixed(2)}`);
+        lines.push("");
+        // Trading metrics
+        lines.push("### Trading Performance");
+        lines.push(`- Total P&L: $${metrics.trading.totalPnL.toFixed(2)}`);
+        lines.push(`- Win Rate: ${(metrics.trading.winRate * 100).toFixed(1)}%`);
+        lines.push(`- Sharpe Ratio: ${metrics.trading.sharpeRatio.toFixed(2)}`);
+        lines.push(`- Max Drawdown: $${metrics.trading.maxDrawdown.toFixed(2)}`);
+        lines.push(`- Markets Traded: ${metrics.trading.marketsTraded}`);
+        lines.push(`- Largest Win: $${metrics.trading.largestWin.toFixed(2)}`);
+        lines.push(`- Largest Loss: $${metrics.trading.largestLoss.toFixed(2)}`);
+        lines.push("");
+        // Influence metrics
+        lines.push("### Influence");
+        lines.push(`- Followers Gained: ${metrics.influence.followersGained}`);
+        lines.push(`- Reputation Delta: ${metrics.influence.reputationDelta > 0 ? "+" : ""}${metrics.influence.reputationDelta}`);
+        lines.push(`- Positive Reactions: ${metrics.influence.positiveReactions}`);
+        lines.push(`- Information Spread: ${metrics.influence.informationSpread}`);
+        lines.push("");
+        // Behavior metrics
+        lines.push("### Behavior Patterns");
+        lines.push(`- Actions Per Tick: ${metrics.behavior.actionsPerTick.toFixed(2)}`);
+        lines.push(`- Consistency Score: ${(metrics.behavior.consistencyScore * 100).toFixed(1)}%`);
+        lines.push(`- Dominant Action: ${metrics.behavior.dominantActionType || "none"}`);
+        lines.push("");
+        // Information metrics
+        lines.push("### Information Activity");
+        lines.push(`- Research Actions: ${metrics.information.researchActions}`);
+        lines.push(`- Predictions Made: ${metrics.information.predictionsMade}`);
+        lines.push(`- Prediction Accuracy: ${(metrics.information.predictionAccuracy * 100).toFixed(1)}%`);
+        return lines.join("\n");
+    }
+    /**
+     * Get a metric value from the metrics object using a dot-path
+     */
+    getMetricValue(metrics, path) {
+        const [category, key] = path.split(".");
+        if (!category || !key)
+            return "N/A";
+        // Access nested metric value based on category
+        let value;
+        switch (category) {
+            case "trading":
+                value = metrics.trading[key];
+                break;
+            case "social":
+                value = metrics.social[key];
+                break;
+            case "influence":
+                value = metrics.influence[key];
+                break;
+            case "behavior":
+                value = metrics.behavior[key];
+                break;
+            case "information":
+                value = metrics.information[key];
+                break;
+            default:
+                return "N/A";
+        }
+        if (value === undefined || value === null)
+            return "N/A";
+        // Format based on value type
+        if (typeof value === "number") {
+            // Check if it's a rate/percentage
+            if (key.includes("Rate") ||
+                key.includes("Accuracy") ||
+                key.includes("Score")) {
+                return `${(value * 100).toFixed(1)}%`;
+            }
+            // Check if it's a currency
+            if (key.includes("PnL") ||
+                key.includes("Win") ||
+                key.includes("Loss") ||
+                key.includes("Drawdown")) {
+                return `$${value.toFixed(2)}`;
+            }
+            // Check if it's a ratio
+            if (key.includes("Ratio")) {
+                return value.toFixed(2);
+            }
+            // Integer-like values
+            if (Number.isInteger(value)) {
+                return String(value);
+            }
+            return value.toFixed(2);
+        }
+        return String(value);
+    }
+    /**
+     * Format a metric path into a human-readable label
+     */
+    formatMetricLabel(path) {
+        const [, key] = path.split(".");
+        if (!key)
+            return path;
+        // Convert camelCase to Title Case with spaces
+        return key
+            .replace(/([A-Z])/g, " $1")
+            .replace(/^./, (str) => str.toUpperCase())
+            .trim();
+    }
+    /**
+     * Summarize actions in trajectory
+     */
+    summarizeActions(steps) {
+        const actionCounts = new Map();
+        let successCount = 0;
+        let errorCount = 0;
+        for (const step of steps) {
+            const action = step.action;
+            if (!action)
+                continue;
+            const actionType = action.actionType;
+            actionCounts.set(actionType, (actionCounts.get(actionType) || 0) + 1);
+            if (action.success) {
+                successCount++;
+            }
+            else {
+                errorCount++;
+            }
+        }
+        const sortedActions = Array.from(actionCounts.entries()).sort((a, b) => b[1] - a[1]);
+        const lines = [];
+        lines.push(`- Total Actions: ${steps.length} (${successCount} successful, ${errorCount} failed)`);
+        lines.push(`- Action Types: ${sortedActions.map(([type, count]) => `${type}(${count})`).join(", ")}`);
+        return lines.join("\n");
+    }
+    /**
+     * Extract key decisions (trades, significant social actions)
+     */
+    extractKeyDecisions(steps) {
+        const keyActions = [];
+        const keyActionTypes = new Set([
+            "trade",
+            "buy",
+            "sell",
+            "predict",
+            "create_group_chat",
+            "post",
+        ]);
+        for (const step of steps) {
+            const action = step.action;
+            if (!action)
+                continue;
+            if (keyActionTypes.has(action.actionType.toLowerCase())) {
+                const params = action.parameters || {};
+                const result = action.result || {};
+                let description = `${action.actionType}`;
+                // Add relevant details
+                if (params.amount || params.size) {
+                    description += ` (size: ${params.amount || params.size})`;
+                }
+                if (params.marketId || params.market) {
+                    description += ` on ${params.marketId || params.market}`;
+                }
+                if (result.pnl !== undefined) {
+                    const pnl = Number(result.pnl);
+                    description += ` → P&L: ${pnl >= 0 ? "+" : ""}$${pnl.toFixed(2)}`;
+                }
+                keyActions.push(`- ${description} ${action.success ? "✓" : "✗"}`);
+            }
+        }
+        if (keyActions.length === 0) {
+            return null;
+        }
+        // Limit to most recent 10 key actions
+        return keyActions.slice(-10).join("\n");
+    }
+    /**
+     * Format recent actions for detailed view
+     */
+    formatRecentActions(steps, maxActions) {
+        const recentSteps = steps.slice(-maxActions);
+        const lines = [];
+        for (const step of recentSteps) {
+            const action = step.action;
+            if (!action)
+                continue;
+            const success = action.success ? "✓" : "✗";
+            const reasoning = action.reasoning
+                ? ` | Reason: ${action.reasoning.substring(0, 50)}...`
+                : "";
+            lines.push(`- [${step.stepNumber}] ${action.actionType} ${success}${reasoning}`);
+        }
+        return lines.join("\n") || "No actions recorded";
+    }
+}
+/**
+ * Singleton instance
+ */
+export const judgePromptBuilder = new JudgePromptBuilder();

package/dist/scoring/LLMJudgeCache.js

@@ -0,0 +1,263 @@
+/**
+ * LLMJudgeCache
+ *
+ * Caches LLM-as-judge scoring results to:
+ * 1. Avoid redundant API calls for identical trajectories
+ * 2. Enable fast re-scoring when rubrics change
+ * 3. Provide validation of cached scores
+ *
+ * Uses content-addressable hashing: cache key = hash(trajectory_content + rubric_version)
+ *
+ * @packageDocumentation
+ */
+import { createHash } from "node:crypto";
+import { getTrainingDataAdapter } from "../adapter";
+import { getRubricHash, RUBRICS_VERSION } from "../rubrics";
+import { logger } from "../utils/logger";
+const DEFAULT_CONFIG = {
+    ttlHours: 168, // 1 week
+    maxEntries: 10000,
+    validateRubricVersion: true,
+};
+/**
+ * In-memory LLM judge cache with validation
+ */
+export class LLMJudgeCache {
+    cache = new Map();
+    config;
+    stats = {
+        hits: 0,
+        misses: 0,
+        invalidations: 0,
+        hitRate: 0,
+    };
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Generate a cache key from trajectory content and archetype
+     */
+    generateCacheKey(trajectoryId, stepsJson, archetype) {
+        const content = `${trajectoryId}:${stepsJson}:${archetype}:${RUBRICS_VERSION}`;
+        return createHash("sha256").update(content).digest("hex").substring(0, 32);
+    }
+    /**
+     * Check if a cached score is valid
+     */
+    isValid(cached, archetype) {
+        // Check expiration
+        if (new Date() > cached.expiresAt) {
+            return false;
+        }
+        // Check rubric version if validation is enabled
+        if (this.config.validateRubricVersion) {
+            if (cached.rubricVersion !== RUBRICS_VERSION) {
+                return false;
+            }
+            // Check rubric hash for this specific archetype
+            const currentRubricHash = getRubricHash(archetype);
+            if (cached.rubricHash !== currentRubricHash) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Get a cached score if available and valid
+     */
+    get(trajectoryId, stepsJson, archetype) {
+        const cacheKey = this.generateCacheKey(trajectoryId, stepsJson, archetype);
+        const cached = this.cache.get(cacheKey);
+        if (!cached) {
+            this.stats.misses++;
+            this.updateHitRate();
+            return null;
+        }
+        if (!this.isValid(cached, archetype)) {
+            this.cache.delete(cacheKey);
+            this.stats.invalidations++;
+            this.stats.misses++;
+            this.updateHitRate();
+            return null;
+        }
+        this.stats.hits++;
+        this.updateHitRate();
+        logger.debug("Cache hit", { trajectoryId, archetype, cacheKey: cacheKey.substring(0, 8) }, "LLMJudgeCache");
+        return cached;
+    }
+    /**
+     * Store a score in the cache
+     */
+    set(trajectoryId, stepsJson, archetype, score, reasoning, strengths = [], weaknesses = []) {
+        // Enforce max entries limit
+        if (this.cache.size >= this.config.maxEntries) {
+            this.evictOldest();
+        }
+        const cacheKey = this.generateCacheKey(trajectoryId, stepsJson, archetype);
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + this.config.ttlHours * 60 * 60 * 1000);
+        const entry = {
+            cacheKey,
+            trajectoryId,
+            archetype,
+            score,
+            reasoning,
+            strengths,
+            weaknesses,
+            rubricVersion: RUBRICS_VERSION,
+            rubricHash: getRubricHash(archetype),
+            scoredAt: now,
+            expiresAt,
+        };
+        this.cache.set(cacheKey, entry);
+        logger.debug("Cache set", { trajectoryId, archetype, score, cacheKey: cacheKey.substring(0, 8) }, "LLMJudgeCache");
+    }
+    /**
+     * Evict the oldest cache entry
+     */
+    evictOldest() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            const entryTime = entry.scoredAt.getTime();
+            if (entryTime < oldestTime) {
+                oldestTime = entryTime;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+        }
+    }
+    /**
+     * Update hit rate statistic
+     */
+    updateHitRate() {
+        const total = this.stats.hits + this.stats.misses;
+        this.stats.hitRate = total > 0 ? this.stats.hits / total : 0;
+    }
+    /**
+     * Invalidate all cache entries for an archetype (when rubric changes)
+     */
+    invalidateArchetype(archetype) {
+        let invalidated = 0;
+        for (const [key, entry] of this.cache) {
+            if (entry.archetype === archetype) {
+                this.cache.delete(key);
+                invalidated++;
+            }
+        }
+        this.stats.invalidations += invalidated;
+        logger.info("Invalidated cache entries", { archetype, count: invalidated }, "LLMJudgeCache");
+        return invalidated;
+    }
+    /**
+     * Invalidate all cache entries
+     */
+    clear() {
+        const count = this.cache.size;
+        this.cache.clear();
+        this.stats.invalidations += count;
+        logger.info("Cleared cache", { count }, "LLMJudgeCache");
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get cache size
+     */
+    size() {
+        return this.cache.size;
+    }
+    /**
+     * Warm cache from database
+     * Loads previously scored trajectories into cache
+     */
+    async warmFromDatabase(limit = 1000) {
+        const results = await getTrainingDataAdapter().getScoredTrajectories(limit);
+        let loaded = 0;
+        for (const row of results) {
+            if (row.aiJudgeReward !== null && row.aiJudgeReasoning && row.judgedAt) {
+                // Use 'default' archetype for warmed entries since archetype isn't stored
+                this.set(row.trajectoryId, row.stepsJson, "default", row.aiJudgeReward, row.aiJudgeReasoning);
+                loaded++;
+            }
+        }
+        logger.info("Warmed cache from database", { loaded, attempted: results.length }, "LLMJudgeCache");
+        return loaded;
+    }
+}
+/**
+ * Singleton cache instance
+ */
+export const llmJudgeCache = new LLMJudgeCache();
+/**
+ * Score validation utilities
+ */
+export const scoreValidator = {
+    /**
+     * Validate a score is in valid range
+     */
+    isValidScore(score) {
+        return (typeof score === "number" &&
+            !Number.isNaN(score) &&
+            score >= 0 &&
+            score <= 1);
+    },
+    /**
+     * Validate reasoning is meaningful
+     */
+    isValidReasoning(reasoning) {
+        return (typeof reasoning === "string" &&
+            reasoning.length >= 20 &&
+            reasoning.length <= 5000);
+    },
+    /**
+     * Validate a complete score response
+     */
+    isValidScoreResponse(response) {
+        return (this.isValidScore(response.score) &&
+            this.isValidReasoning(response.reasoning));
+    },
+    /**
+     * Check if scores are consistent (similar trajectories should have similar scores)
+     */
+    checkScoreConsistency(scores) {
+        if (scores.length < 3) {
+            return { consistent: true, outliers: [] };
+        }
+        // Group by metrics hash
+        const byMetrics = new Map();
+        for (const s of scores) {
+            const existing = byMetrics.get(s.metricsHash) || [];
+            existing.push(s.score);
+            byMetrics.set(s.metricsHash, existing);
+        }
+        const outliers = [];
+        // Check variance within groups
+        for (const [hash, groupScores] of byMetrics) {
+            if (groupScores.length < 2)
+                continue;
+            const mean = groupScores.reduce((a, b) => a + b) / groupScores.length;
+            const variance = groupScores.reduce((sum, s) => sum + (s - mean) ** 2, 0) /
+                groupScores.length;
+            const stdDev = Math.sqrt(variance);
+            // Flag if std deviation is too high (inconsistent scoring)
+            if (stdDev > 0.2) {
+                // Find trajectories in this group
+                for (const s of scores) {
+                    if (s.metricsHash === hash && Math.abs(s.score - mean) > 2 * stdDev) {
+                        outliers.push(s.trajectoryId);
+                    }
+                }
+            }
+        }
+        return {
+            consistent: outliers.length === 0,
+            outliers,
+        };
+    },
+};

package/dist/scoring/index.js

@@ -0,0 +1,8 @@
+/**
+ * Scoring Module
+ *
+ * LLM-as-judge scoring with archetype-specific rubrics.
+ */
+export * from "./ArchetypeScoringService";
+export * from "./JudgePromptBuilder";
+export * from "./LLMJudgeCache";