@agents-uni/zhenhuan 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,253 @@
+/**
+ * Zhen Huan CLI - 后宫命令行工具
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { PalaceOrchestrator } from '../orchestrator/index.js';
+import { startServer } from '../server/index.js';
+const program = new Command();
+program
+    .name('zhenhuan')
+    .description('甄嬛后宫 Agent 赛马系统 —— 你是皇帝，Agent 为你竞争')
+    .version('0.1.0');
+// ─── serve ──────────────────────────────────
+program
+    .command('serve')
+    .description('启动后宫服务器')
+    .option('-p, --port <port>', '端口号', '8089')
+    .option('-s, --spec <path>', '规范文件路径', 'universe.yaml')
+    .action(async (opts) => {
+    // Auto-register in uni-registry on serve
+    try {
+        const { resolve } = await import('node:path');
+        const { registerUni, parseSpecFile } = await import('@agents-uni/core');
+        const specPath = resolve(opts.spec);
+        const config = parseSpecFile(specPath);
+        registerUni(config, specPath);
+        console.log(chalk.gray(`  ✓ 已注册到 uni-registry`));
+    }
+    catch {
+        // Registry registration is non-critical
+    }
+    await startServer({
+        port: parseInt(opts.port, 10),
+        specPath: opts.spec,
+    });
+});
+// ─── status ─────────────────────────────────
+program
+    .command('status')
+    .description('查看后宫状态')
+    .option('-s, --spec <path>', '规范文件路径', 'universe.yaml')
+    .action(async (opts) => {
+    const orchestrator = await PalaceOrchestrator.fromSpec(opts.spec);
+    const state = orchestrator.getState();
+    console.log(chalk.yellow('\n═══ 后宫品级表 ═══\n'));
+    // Sort by rank level descending
+    const sorted = [...state.agents].sort((a, b) => b.rankLevel - a.rankLevel);
+    for (const agent of sorted) {
+        const statusIcon = agent.status === 'active' || agent.status === 'idle' ? '●' : '○';
+        const statusColor = agent.status === 'active' || agent.status === 'idle' ? chalk.green : chalk.red;
+        console.log(`  ${statusColor(statusIcon)} ${chalk.bold(agent.name.padEnd(10))} ` +
+            `${chalk.cyan(agent.rank.padEnd(6))} ` +
+            `ELO: ${chalk.yellow(String(agent.elo).padStart(4))}  ` +
+            `圣宠: ${chalk.magenta(String(agent.favor).padStart(3))}`);
+    }
+    if (state.factions.length > 0) {
+        console.log(chalk.yellow('\n═══ 势力格局 ═══\n'));
+        for (const faction of state.factions) {
+            console.log(`  ${chalk.bold(faction.leader)} 派系: ` +
+                `${faction.members.join(', ')} ` +
+                `(影响力: ${chalk.cyan(String(faction.influence))})`);
+        }
+    }
+    if (state.coldPalaceInmates.length > 0) {
+        console.log(chalk.yellow('\n═══ 冷宫 ═══\n'));
+        for (const inmate of state.coldPalaceInmates) {
+            console.log(`  ${chalk.gray('○')} ${inmate}`);
+        }
+    }
+    console.log();
+});
+// ─── leaderboard ────────────────────────────
+program
+    .command('leaderboard')
+    .description('查看 ELO 排行榜')
+    .option('-s, --spec <path>', '规范文件路径', 'universe.yaml')
+    .action(async (opts) => {
+    const orchestrator = await PalaceOrchestrator.fromSpec(opts.spec);
+    const board = orchestrator.getLeaderboard();
+    console.log(chalk.yellow('\n═══ ELO 排行榜 ═══\n'));
+    console.log(`  ${chalk.gray('排名')}  ${chalk.gray('ID'.padEnd(16))} ` +
+        `${chalk.gray('ELO'.padStart(5))}  ${chalk.gray('胜'.padStart(3))} ` +
+        `${chalk.gray('负'.padStart(3))}  ${chalk.gray('胜率'.padStart(5))}`);
+    console.log(chalk.gray('  ─'.repeat(20)));
+    board.forEach((record, index) => {
+        const winRate = record.matchCount > 0
+            ? (record.winCount / record.matchCount * 100).toFixed(0) + '%'
+            : '  -';
+        const medal = index === 0 ? '🥇' : index === 1 ? '🥈' : index === 2 ? '🥉' : '  ';
+        console.log(`  ${medal} ${chalk.bold(record.agentId.padEnd(16))} ` +
+            `${chalk.yellow(String(record.rating).padStart(5))}  ` +
+            `${chalk.green(String(record.winCount).padStart(3))} ` +
+            `${chalk.red(String(record.lossCount).padStart(3))}  ` +
+            `${winRate.padStart(5)}`);
+    });
+    console.log();
+});
+// ─── court ──────────────────────────────────
+program
+    .command('court')
+    .description('召开朝会')
+    .option('-s, --spec <path>', '规范文件路径', 'universe.yaml')
+    .action(async (opts) => {
+    const orchestrator = await PalaceOrchestrator.fromSpec(opts.spec);
+    console.log(chalk.yellow('\n═══ 朝会开始 ═══\n'));
+    await orchestrator.runCourtAssembly();
+    const state = orchestrator.getState();
+    for (const event of state.recentEvents.slice(-5)) {
+        console.log(`  ${chalk.gray(event.timestamp.slice(0, 19))} ${event.description}`);
+    }
+    console.log(chalk.yellow('\n═══ 朝会结束 ═══\n'));
+});
+// ─── select ────────────────────────────
+program
+    .command('select')
+    .description('选秀 — 一键注册新 Agent 并加入后宫竞技')
+    .requiredOption('--id <id>', 'Agent ID')
+    .requiredOption('--name <name>', 'Agent 名称')
+    .option('--role <role>', '初始品级', '答应')
+    .option('--rank <rank>', '品级数值 (10=答应, 20=常在, ...)', '10')
+    .option('--register', '同时注册到 openclaw.json', false)
+    .option('--openclaw-dir <dir>', 'OpenClaw 目录', '')
+    .option('-s, --spec <path>', '规范文件路径', 'universe.yaml')
+    .action(async (opts) => {
+    const orchestrator = await PalaceOrchestrator.fromSpec(opts.spec);
+    const agentDef = {
+        id: opts.id,
+        name: opts.name,
+        role: { title: opts.role, duties: [], permissions: [] },
+        rank: parseInt(opts.rank, 10),
+    };
+    console.log(chalk.yellow('\n═══ 选秀大典 ═══\n'));
+    console.log(`  候选: ${chalk.bold(agentDef.name)} (${chalk.cyan(agentDef.id)})`);
+    console.log(`  品级: ${chalk.cyan(agentDef.role.title)}`);
+    const result = await orchestrator.ceremonies.conductSelection([agentDef]);
+    const selected = result.outcomes.filter(o => o.action === 'selected');
+    const failed = result.outcomes.filter(o => o.action === 'selection_failed');
+    if (selected.length > 0) {
+        // Register in ELO arena
+        orchestrator.arena.register(agentDef.id, 1000);
+        console.log(chalk.green(`\n  ✓ ${agentDef.name} 入宫成功！初始 ELO: 1000`));
+        // Auto-register in openclaw.json if requested
+        if (opts.register) {
+            const { registerAgentsInOpenClaw } = await import('@agents-uni/core');
+            const uniConfig = orchestrator.universe.config;
+            const miniConfig = {
+                ...uniConfig,
+                agents: [agentDef],
+            };
+            const registered = registerAgentsInOpenClaw(miniConfig, opts.openclawDir || undefined);
+            if (registered.length > 0) {
+                console.log(chalk.green(`  ✓ 已注册到 openclaw.json`));
+            }
+            else {
+                console.log(chalk.gray(`  - openclaw.json 中已存在或未找到配置文件`));
+            }
+        }
+    }
+    if (failed.length > 0) {
+        for (const f of failed) {
+            console.log(chalk.red(`\n  ✗ 选秀失败: ${f.details.reason}`));
+        }
+    }
+    console.log(chalk.gray(`\n  ${result.narrative}`));
+    console.log();
+});
+// ─── race ───────────────────────────────────
+program
+    .command('race')
+    .description('发起赛马竞技 — 下发任务到 OpenClaw 工作区，收集产出并评判')
+    .requiredOption('-t, --task <title>', '赛马任务标题')
+    .option('-d, --description <desc>', '任务描述', '')
+    .option('--timeout <ms>', '超时时间（毫秒）', '60000')
+    .option('-s, --spec <path>', '规范文件路径', 'universe.yaml')
+    .option('--agents <ids>', '参赛 Agent ID (逗号分隔，默认全部嫔妃)', '')
+    .action(async (opts) => {
+    const orchestrator = await PalaceOrchestrator.fromSpec(opts.spec);
+    // Determine participants: all agents by default (emperor is the user, not an agent)
+    let participants;
+    if (opts.agents) {
+        participants = opts.agents.split(',').map((s) => s.trim());
+    }
+    else {
+        const state = orchestrator.getState();
+        participants = state.agents
+            .filter(a => a.rank !== '未知')
+            .map(a => a.id);
+    }
+    if (participants.length < 2) {
+        console.log(chalk.red('\n  ✗ 至少需要 2 名参赛者\n'));
+        process.exit(1);
+    }
+    const taskId = `race-${Date.now()}`;
+    const timeoutMs = parseInt(opts.timeout, 10);
+    console.log(chalk.yellow('\n═══ 赛马开始 ═══\n'));
+    console.log(`  任务: ${chalk.bold(opts.task)}`);
+    console.log(`  参赛: ${chalk.cyan(participants.join(', '))}`);
+    console.log(`  超时: ${chalk.gray(timeoutMs / 1000 + 's')}`);
+    console.log(`  任务文件已下发到各 OpenClaw workspace 的 TASK.md`);
+    console.log(chalk.gray('\n  等待各 Agent 提交 SUBMISSION.md ...\n'));
+    const { dispatch, race } = await orchestrator.dispatchAndRace({
+        id: taskId,
+        title: opts.task,
+        description: opts.description || opts.task,
+        criteria: [
+            { name: '质量', weight: 0.5, description: '输出质量和完整度' },
+            { name: '创意', weight: 0.3, description: '创新性和独特视角' },
+            { name: '速度', weight: 0.2, description: '完成速度' },
+        ],
+        timeoutMs,
+        participants,
+    }, 
+    // Default judge (placeholder — in production, call LLM)
+    async (task, entries) => {
+        return entries.map(entry => {
+            const criterionScores = new Map();
+            for (const criterion of task.criteria) {
+                criterionScores.set(criterion.name, 50 + Math.random() * 50);
+            }
+            let totalScore = 0;
+            let totalWeight = 0;
+            for (const criterion of task.criteria) {
+                totalScore += (criterionScores.get(criterion.name) ?? 50) * criterion.weight;
+                totalWeight += criterion.weight;
+            }
+            if (totalWeight > 0)
+                totalScore /= totalWeight;
+            return { agentId: entry.agentId, criterionScores, totalScore, feedback: '评分完毕' };
+        });
+    });
+    // Report dispatch results
+    console.log(chalk.green(`  ✓ 收到 ${dispatch.submissions.length} 份提交`));
+    if (dispatch.timedOut.length > 0) {
+        console.log(chalk.red(`  ✗ 超时未提交: ${dispatch.timedOut.join(', ')}`));
+    }
+    // Report race results
+    if (race) {
+        console.log(chalk.yellow('\n═══ 赛马结果 ═══\n'));
+        race.rankings.forEach((agentId, index) => {
+            const medal = index === 0 ? '🥇' : index === 1 ? '🥈' : index === 2 ? '🥉' : '  ';
+            const judgment = race.judgments.find(j => j.agentId === agentId);
+            const score = judgment ? judgment.totalScore.toFixed(1) : '-';
+            const eloChange = race.eloChanges.get(agentId) ?? 0;
+            const eloStr = eloChange >= 0 ? chalk.green(`+${eloChange}`) : chalk.red(`${eloChange}`);
+            console.log(`  ${medal} ${chalk.bold(agentId.padEnd(16))} 得分: ${chalk.yellow(score)}  ELO: ${eloStr}`);
+        });
+    }
+    else {
+        console.log(chalk.gray('\n  提交不足 2 份，无法进行评判\n'));
+    }
+    console.log();
+});
+program.parse();

package/dist/competition/elo.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ELO Rating System - 后宫竞技评分
+ *
+ * Implements ELO-based competitive ranking for palace agents.
+ * Agents gain/lose ELO through task competitions, direct challenges,
+ * and performance evaluations.
+ */
+export interface EloRecord {
+    agentId: string;
+    rating: number;
+    peakRating: number;
+    matchCount: number;
+    winCount: number;
+    lossCount: number;
+    drawCount: number;
+    streak: number;
+    history: EloChange[];
+}
+export interface EloChange {
+    timestamp: string;
+    opponent: string;
+    oldRating: number;
+    newRating: number;
+    result: 'win' | 'loss' | 'draw';
+    reason: string;
+}
+export interface MatchResult {
+    winner: string;
+    loser: string;
+    isDraw: boolean;
+    reason: string;
+    /** Score difference (0-1, higher = more decisive) */
+    margin: number;
+}
+/**
+ * ELO arena for palace agent competitions.
+ */
+export declare class EloArena {
+    private records;
+    constructor();
+    /** Register an agent with starting ELO */
+    register(agentId: string, initialRating?: number): void;
+    /** Get an agent's current rating */
+    getRating(agentId: string): number;
+    /** Get an agent's full record */
+    getRecord(agentId: string): EloRecord | undefined;
+    /** Record a match result and update ELO ratings */
+    recordMatch(result: MatchResult): {
+        winnerDelta: number;
+        loserDelta: number;
+    };
+    /** Get leaderboard sorted by ELO rating */
+    getLeaderboard(): EloRecord[];
+    /** Get win rate for an agent */
+    getWinRate(agentId: string): number;
+    /** Calculate expected score between two ratings */
+    private expectedScore;
+    /** Determine K-factor based on agent experience and rating */
+    private getKFactor;
+    /** Ensure an agent is registered before a match */
+    private ensureRegistered;
+}

package/dist/competition/elo.js

@@ -0,0 +1,146 @@
+/**
+ * ELO Rating System - 后宫竞技评分
+ *
+ * Implements ELO-based competitive ranking for palace agents.
+ * Agents gain/lose ELO through task competitions, direct challenges,
+ * and performance evaluations.
+ */
+/** Default K-factor for ELO calculation */
+const DEFAULT_K = 32;
+/** K-factor for new agents (first 10 matches) */
+const PROVISIONAL_K = 48;
+/** K-factor for high-rated agents (2000+) */
+const HIGH_RATING_K = 16;
+/** Default starting rating */
+const DEFAULT_RATING = 1200;
+/**
+ * ELO arena for palace agent competitions.
+ */
+export class EloArena {
+    records;
+    constructor() {
+        this.records = new Map();
+    }
+    /** Register an agent with starting ELO */
+    register(agentId, initialRating = DEFAULT_RATING) {
+        if (this.records.has(agentId))
+            return;
+        this.records.set(agentId, {
+            agentId,
+            rating: initialRating,
+            peakRating: initialRating,
+            matchCount: 0,
+            winCount: 0,
+            lossCount: 0,
+            drawCount: 0,
+            streak: 0,
+            history: [],
+        });
+    }
+    /** Get an agent's current rating */
+    getRating(agentId) {
+        return this.records.get(agentId)?.rating ?? DEFAULT_RATING;
+    }
+    /** Get an agent's full record */
+    getRecord(agentId) {
+        return this.records.get(agentId);
+    }
+    /** Record a match result and update ELO ratings */
+    recordMatch(result) {
+        this.ensureRegistered(result.winner);
+        this.ensureRegistered(result.loser);
+        const winnerRecord = this.records.get(result.winner);
+        const loserRecord = this.records.get(result.loser);
+        const kWinner = this.getKFactor(winnerRecord);
+        const kLoser = this.getKFactor(loserRecord);
+        // Expected scores
+        const expectedWinner = this.expectedScore(winnerRecord.rating, loserRecord.rating);
+        const expectedLoser = 1 - expectedWinner;
+        let actualWinner;
+        let actualLoser;
+        if (result.isDraw) {
+            actualWinner = 0.5;
+            actualLoser = 0.5;
+        }
+        else {
+            // Margin-adjusted score (0.75-1.0 for winner based on margin)
+            actualWinner = 0.75 + result.margin * 0.25;
+            actualLoser = 0;
+        }
+        const winnerDelta = Math.round(kWinner * (actualWinner - expectedWinner));
+        const loserDelta = Math.round(kLoser * (actualLoser - expectedLoser));
+        const now = new Date().toISOString();
+        // Update winner
+        const oldWinnerRating = winnerRecord.rating;
+        winnerRecord.rating += winnerDelta;
+        winnerRecord.peakRating = Math.max(winnerRecord.peakRating, winnerRecord.rating);
+        winnerRecord.matchCount++;
+        if (result.isDraw) {
+            winnerRecord.drawCount++;
+            winnerRecord.streak = 0;
+        }
+        else {
+            winnerRecord.winCount++;
+            winnerRecord.streak = winnerRecord.streak > 0 ? winnerRecord.streak + 1 : 1;
+        }
+        winnerRecord.history.push({
+            timestamp: now,
+            opponent: result.loser,
+            oldRating: oldWinnerRating,
+            newRating: winnerRecord.rating,
+            result: result.isDraw ? 'draw' : 'win',
+            reason: result.reason,
+        });
+        // Update loser
+        const oldLoserRating = loserRecord.rating;
+        loserRecord.rating += loserDelta;
+        loserRecord.rating = Math.max(loserRecord.rating, 100); // floor at 100
+        loserRecord.matchCount++;
+        if (result.isDraw) {
+            loserRecord.drawCount++;
+            loserRecord.streak = 0;
+        }
+        else {
+            loserRecord.lossCount++;
+            loserRecord.streak = loserRecord.streak < 0 ? loserRecord.streak - 1 : -1;
+        }
+        loserRecord.history.push({
+            timestamp: now,
+            opponent: result.winner,
+            oldRating: oldLoserRating,
+            newRating: loserRecord.rating,
+            result: result.isDraw ? 'draw' : 'loss',
+            reason: result.reason,
+        });
+        return { winnerDelta, loserDelta };
+    }
+    /** Get leaderboard sorted by ELO rating */
+    getLeaderboard() {
+        return [...this.records.values()].sort((a, b) => b.rating - a.rating);
+    }
+    /** Get win rate for an agent */
+    getWinRate(agentId) {
+        const record = this.records.get(agentId);
+        if (!record || record.matchCount === 0)
+            return 0;
+        return record.winCount / record.matchCount;
+    }
+    /** Calculate expected score between two ratings */
+    expectedScore(ratingA, ratingB) {
+        return 1 / (1 + Math.pow(10, (ratingB - ratingA) / 400));
+    }
+    /** Determine K-factor based on agent experience and rating */
+    getKFactor(record) {
+        if (record.matchCount < 10)
+            return PROVISIONAL_K;
+        if (record.rating >= 2000)
+            return HIGH_RATING_K;
+        return DEFAULT_K;
+    }
+    /** Ensure an agent is registered before a match */
+    ensureRegistered(agentId) {
+        if (!this.records.has(agentId)) {
+            this.register(agentId);
+        }
+    }
+}

package/dist/competition/horse-race.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Horse Race Engine - 赛马机制
+ *
+ * Multiple agents compete on the same task in parallel.
+ * A judge evaluates outputs and determines winners/losers.
+ * Results feed back into ELO ratings and rank progression.
+ */
+import type { EloArena } from './elo.js';
+export interface HorseRaceTask {
+    id: string;
+    title: string;
+    description: string;
+    /** Maximum time allowed (ms) */
+    timeLimit: number;
+    /** Difficulty tier (1-5) */
+    difficulty: number;
+    /** Category for scoring */
+    category: string;
+    /** Evaluation criteria with weights */
+    criteria: EvaluationCriterion[];
+}
+export interface EvaluationCriterion {
+    name: string;
+    weight: number;
+    description: string;
+}
+export interface RaceEntry {
+    agentId: string;
+    output: string;
+    completedAt: string;
+    /** Time taken in ms */
+    duration: number;
+}
+export interface JudgmentScore {
+    agentId: string;
+    criterionScores: Map<string, number>;
+    totalScore: number;
+    feedback: string;
+}
+export interface RaceResult {
+    taskId: string;
+    startedAt: string;
+    completedAt: string;
+    entries: RaceEntry[];
+    judgments: JudgmentScore[];
+    rankings: string[];
+    eloChanges: Map<string, number>;
+    narrative: string;
+}
+export type JudgeFunction = (task: HorseRaceTask, entries: RaceEntry[]) => Promise<JudgmentScore[]>;
+/**
+ * Runs competitive horse races between agents.
+ */
+export declare class HorseRaceEngine {
+    private arena;
+    private history;
+    constructor(arena: EloArena);
+    /**
+     * Evaluate a completed race: judge entries, update ELO, return results.
+     */
+    evaluateRace(task: HorseRaceTask, entries: RaceEntry[], judge: JudgeFunction): Promise<RaceResult>;
+    /** Get race history */
+    getHistory(): RaceResult[];
+    /** Get an agent's race statistics */
+    getAgentStats(agentId: string): {
+        totalRaces: number;
+        firstPlace: number;
+        topThree: number;
+        averageScore: number;
+    };
+    private generateNarrative;
+}

package/dist/competition/horse-race.js

@@ -0,0 +1,110 @@
+/**
+ * Horse Race Engine - 赛马机制
+ *
+ * Multiple agents compete on the same task in parallel.
+ * A judge evaluates outputs and determines winners/losers.
+ * Results feed back into ELO ratings and rank progression.
+ */
+/**
+ * Runs competitive horse races between agents.
+ */
+export class HorseRaceEngine {
+    arena;
+    history;
+    constructor(arena) {
+        this.arena = arena;
+        this.history = [];
+    }
+    /**
+     * Evaluate a completed race: judge entries, update ELO, return results.
+     */
+    async evaluateRace(task, entries, judge) {
+        if (entries.length < 2) {
+            throw new Error('Horse race requires at least 2 entries');
+        }
+        // Get judgments from the judge function
+        const judgments = await judge(task, entries);
+        // Sort by total score to get rankings
+        const sorted = [...judgments].sort((a, b) => b.totalScore - a.totalScore);
+        const rankings = sorted.map(j => j.agentId);
+        // Update ELO for all pairwise matchups
+        const eloChanges = new Map();
+        for (const id of rankings) {
+            eloChanges.set(id, 0);
+        }
+        for (let i = 0; i < sorted.length; i++) {
+            for (let j = i + 1; j < sorted.length; j++) {
+                const higher = sorted[i];
+                const lower = sorted[j];
+                const scoreDiff = higher.totalScore - lower.totalScore;
+                const matchResult = {
+                    winner: higher.agentId,
+                    loser: lower.agentId,
+                    isDraw: scoreDiff < 5, // within 5 points = draw
+                    reason: `赛马: ${task.title}`,
+                    margin: Math.min(scoreDiff / 100, 1),
+                };
+                const deltas = this.arena.recordMatch(matchResult);
+                eloChanges.set(higher.agentId, (eloChanges.get(higher.agentId) ?? 0) + deltas.winnerDelta);
+                eloChanges.set(lower.agentId, (eloChanges.get(lower.agentId) ?? 0) + deltas.loserDelta);
+            }
+        }
+        const result = {
+            taskId: task.id,
+            startedAt: entries[0]?.completedAt ?? new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            entries,
+            judgments,
+            rankings,
+            eloChanges,
+            narrative: this.generateNarrative(task, sorted, rankings),
+        };
+        this.history.push(result);
+        return result;
+    }
+    /** Get race history */
+    getHistory() {
+        return [...this.history];
+    }
+    /** Get an agent's race statistics */
+    getAgentStats(agentId) {
+        let totalRaces = 0;
+        let firstPlace = 0;
+        let topThree = 0;
+        let totalScore = 0;
+        for (const race of this.history) {
+            const rankIndex = race.rankings.indexOf(agentId);
+            if (rankIndex === -1)
+                continue;
+            totalRaces++;
+            if (rankIndex === 0)
+                firstPlace++;
+            if (rankIndex < 3)
+                topThree++;
+            const judgment = race.judgments.find(j => j.agentId === agentId);
+            if (judgment) {
+                totalScore += judgment.totalScore;
+            }
+        }
+        return {
+            totalRaces,
+            firstPlace,
+            topThree,
+            averageScore: totalRaces > 0 ? totalScore / totalRaces : 0,
+        };
+    }
+    generateNarrative(task, sorted, rankings) {
+        const parts = [`赛马「${task.title}」结果揭晓：`];
+        if (rankings.length > 0) {
+            const winner = sorted[0];
+            parts.push(`魁首: ${winner.agentId} (${winner.totalScore.toFixed(1)}分)`);
+        }
+        if (rankings.length > 1) {
+            parts.push(`次席: ${sorted[1].agentId} (${sorted[1].totalScore.toFixed(1)}分)`);
+        }
+        if (rankings.length > 2) {
+            parts.push(`探花: ${sorted[2].agentId} (${sorted[2].totalScore.toFixed(1)}分)`);
+        }
+        return parts.join(' ');
+    }
+}

package/dist/competition/index.d.ts

@@ -0,0 +1,6 @@
+export { EloArena } from './elo.js';
+export type { EloRecord, EloChange, MatchResult } from './elo.js';
+export { HorseRaceEngine } from './horse-race.js';
+export type { HorseRaceTask, EvaluationCriterion, RaceEntry, JudgmentScore, RaceResult, JudgeFunction, } from './horse-race.js';
+export { SeasonEngine } from './season.js';
+export type { Season, SeasonConfig, SeasonResult, SeasonStanding } from './season.js';

package/dist/competition/index.js

@@ -0,0 +1,3 @@
+export { EloArena } from './elo.js';
+export { HorseRaceEngine } from './horse-race.js';
+export { SeasonEngine } from './season.js';