@cjhyy/code-shell-arena 0.8.0

package/dist/iterate/iterative-arena.js

@@ -0,0 +1,252 @@
+/**
+ * IterativeArena — multi-model authoring loop.
+ *
+ * Pipeline:
+ *   1. v1: tournament (default) or single-author
+ *   2. for each round 2..maxRounds:
+ *        a. argue (parallel critics)
+ *        b. checkpoint (optional human pause)
+ *        c. convergence check
+ *        d. if not converged: revise → next round
+ *   3. final draft = last round's draft
+ */
+import { logger } from "@cjhyy/code-shell-core/extension";
+import { defaultConvergence, diffRatio } from "./convergence.js";
+import { getFormat } from "./formats/index.js";
+import { runArgueRound } from "./phases/argue.js";
+import { runRevise } from "./phases/revise.js";
+import { mergeCandidatesToV1, runTournamentCandidates, singleAuthorV1 } from "./phases/tournament.js";
+const DEFAULT_MAX_ROUNDS = 5;
+export class IterativeArena {
+    config;
+    constructor(config) {
+        if (!config.author) {
+            throw new Error("IterativeArena requires an `author` participant");
+        }
+        if (!config.critics || config.critics.length === 0) {
+            throw new Error("IterativeArena requires at least 1 critic");
+        }
+        const allNames = [config.author.name, ...config.critics.map((c) => c.name)];
+        if (new Set(allNames).size !== allNames.length) {
+            throw new Error("Author and critics must have unique names");
+        }
+        this.config = config;
+    }
+    async run() {
+        const start = Date.now();
+        const { config } = this;
+        const format = getFormat(config.format);
+        const maxRounds = config.maxRounds ?? DEFAULT_MAX_ROUNDS;
+        const minDraftLength = config.minDraftLength ?? (config.format === "code" ? 200 : 800);
+        const signal = config.signal;
+        const rounds = [];
+        // ─── Phase: v1 ────────────────────────────────────────────
+        let currentDraft;
+        try {
+            if ((config.v1Strategy ?? "tournament") === "tournament") {
+                const candidates = await runTournamentCandidates({
+                    subject: config.subject,
+                    format,
+                    participants: [config.author, ...config.critics],
+                    minDraftLength,
+                    signal,
+                    onProgress: config.onProgress,
+                });
+                currentDraft = await mergeCandidatesToV1({
+                    subject: config.subject,
+                    format,
+                    author: config.author,
+                    candidates,
+                    minDraftLength,
+                    signal,
+                    onProgress: config.onProgress,
+                });
+            }
+            else {
+                currentDraft = await singleAuthorV1({
+                    subject: config.subject,
+                    format,
+                    author: config.author,
+                    minDraftLength,
+                    signal,
+                });
+            }
+        }
+        catch (err) {
+            logger.error("arena.iterate.v1_failed", { error: err.message });
+            throw err;
+        }
+        // Author rotation state. We pick the next author from the pool of
+        // {author, critics} according to the rotation policy.
+        let currentAuthor = config.author;
+        const pool = [config.author, ...config.critics];
+        // ─── Phase: argue/revise loop ────────────────────────────
+        let previousDraft;
+        for (let r = 1; r <= maxRounds; r++) {
+            signal?.throwIfAborted();
+            // Argue against the current draft.
+            const critiques = await runArgueRound({
+                subject: config.subject,
+                format,
+                draft: currentDraft,
+                // Pass the author of THIS round's draft, not the round number: the
+                // draft under review was written by `currentAuthor`.
+                critics: this.criticsForRound(currentAuthor),
+                round: r,
+                enableWebSearch: config.enableWebSearch,
+                maxToolRounds: config.maxArgueToolRounds,
+                signal,
+                onProgress: config.onProgress,
+            });
+            // Convergence check.
+            const convergence = this.checkConvergence({
+                round: r,
+                critiques,
+                draft: currentDraft,
+                previousDraft,
+            });
+            const round = {
+                round: r,
+                draft: currentDraft,
+                critiques,
+                convergence,
+            };
+            // Optional human checkpoint.
+            let userAction;
+            if (config.humanCheckpoint) {
+                config.onProgress?.({ type: "checkpoint_pause", round: r });
+                userAction = await config.humanCheckpoint({
+                    round: r,
+                    draft: currentDraft,
+                    critiques,
+                    convergence,
+                });
+            }
+            rounds.push(round);
+            config.onProgress?.({
+                type: "round_done",
+                round: r,
+                data: {
+                    critiques: critiques.length,
+                    shouldStop: convergence.shouldStop,
+                    userAction,
+                },
+            });
+            if (userAction === "stop") {
+                return this.finalize(rounds, "user_stop", start);
+            }
+            if (userAction !== "force-continue" && convergence.shouldStop) {
+                return this.finalize(rounds, "converged", start);
+            }
+            if (r === maxRounds) {
+                return this.finalize(rounds, "max_rounds", start);
+            }
+            // Revise → v(r+1)
+            previousDraft = currentDraft;
+            currentAuthor = this.pickNextAuthor(currentAuthor, critiques, pool, r);
+            currentDraft = await runRevise({
+                subject: config.subject,
+                format,
+                previous: previousDraft,
+                critiques,
+                author: currentAuthor,
+                minDraftLength,
+                signal,
+                onProgress: config.onProgress,
+            });
+        }
+        return this.finalize(rounds, "max_rounds", start);
+    }
+    /**
+     * Critics for a round = the whole pool minus whoever wrote the draft under
+     * review, so nobody critiques their own text.
+     *
+     * This used to return `config.critics` verbatim, ignoring rotation. Once
+     * `round-robin`/`best-critic` promoted critic B to author, B kept reviewing
+     * the draft B had just written, while the original author A never entered the
+     * critic pool at all — the exact opposite of the intent documented here.
+     */
+    criticsForRound(currentAuthor) {
+        const pool = [this.config.author, ...this.config.critics];
+        const critics = pool.filter((p) => p.name !== currentAuthor.name);
+        // Degenerate config (single participant, or every critic named like the
+        // author): fall back to the configured critics so a round still has
+        // reviewers rather than silently running with none.
+        return critics.length > 0 ? critics : this.config.critics;
+    }
+    checkConvergence(args) {
+        if (this.config.convergenceStrategy && this.config.convergenceStrategy !== "default") {
+            const stop = this.config.convergenceStrategy(args);
+            const blockerCount = args.critiques.filter((c) => c.severity === "blocker").length;
+            const majorCount = args.critiques.filter((c) => c.severity === "major").length;
+            const diffFromPrevious = args.previousDraft
+                ? diffRatio(args.previousDraft.content, args.draft.content)
+                : 1;
+            return {
+                blockerCount,
+                majorCount,
+                totalCritiques: args.critiques.length,
+                diffFromPrevious,
+                shouldStop: stop,
+                reason: stop ? "all_minor_or_praise" : "running",
+            };
+        }
+        return defaultConvergence(args);
+    }
+    pickNextAuthor(current, critiques, pool, round) {
+        const policy = this.config.authorRotation ?? "fixed";
+        if (policy === "fixed")
+            return this.config.author;
+        if (policy === "round-robin") {
+            const idx = round % pool.length;
+            return pool[idx];
+        }
+        if (policy === "best-critic") {
+            // Score critics by sum of severities they raised; tie → most critiques.
+            const sevWeight = {
+                blocker: 5, major: 3, minor: 1, nit: 0.5, praise: 0,
+            };
+            const scores = new Map();
+            for (const c of critiques) {
+                scores.set(c.critic, (scores.get(c.critic) ?? 0) + (sevWeight[c.severity] ?? 0));
+            }
+            let best = current.name;
+            let bestScore = -1;
+            for (const [name, score] of scores) {
+                if (score > bestScore) {
+                    bestScore = score;
+                    best = name;
+                }
+            }
+            const winner = pool.find((p) => p.name === best);
+            return winner ?? current;
+        }
+        return current;
+    }
+    finalize(rounds, stoppedAt, start) {
+        const finalDraft = rounds.at(-1).draft;
+        const result = {
+            subject: this.config.subject,
+            format: this.config.format,
+            rounds,
+            finalDraft,
+            stoppedAt,
+            durationMs: Date.now() - start,
+        };
+        this.config.onProgress?.({
+            type: "iterate_complete",
+            data: {
+                stoppedAt,
+                rounds: rounds.length,
+                finalLength: finalDraft.content.length,
+            },
+        });
+        logger.info("arena.iterate.complete", {
+            stoppedAt,
+            rounds: rounds.length,
+            finalVersion: finalDraft.version,
+            finalLength: finalDraft.content.length,
+        });
+        return result;
+    }
+}

package/dist/iterate/parse.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Parsing helpers for LLM responses in iterate mode.
+ *
+ * We use literal XML-ish markers (<v1_content>…</v1_content>) instead of
+ * pure JSON because LLMs are far more reliable at "write 5000 chars of
+ * markdown then a small JSON block at the end" than at producing one
+ * giant well-formed JSON document with a 5000-char string field.
+ */
+import type { Critique } from "./types.js";
+/**
+ * Extract content between `<tag>` and `</tag>`.
+ *
+ * Forgiving in two ways:
+ *  - Case-insensitive on the tag name.
+ *  - If the closing tag is missing (LLM hit max_tokens mid-output), we still
+ *    return everything after the opening tag, stopping at the next sibling
+ *    tag (e.g. the `<merge_rationale>` block) if present, otherwise EOF.
+ */
+export declare function extractTag(text: string, tag: string): string | null;
+/** Parse merge response: extract v1 content + rationale. Falls back to whole text if markers are missing. */
+export declare function parseMergeResponse(text: string): {
+    content: string;
+    rationale?: string;
+};
+export interface ReviseMeta {
+    acceptedCritiques?: string[];
+    rejectedCritiques?: Array<{
+        id: string;
+        reason: string;
+    }>;
+    changelog?: string;
+}
+/** Parse revise response: extract content + meta JSON. */
+export declare function parseReviseResponse(text: string): {
+    content: string;
+    meta: ReviseMeta;
+};
+/**
+ * Parse critique JSON from an argue-phase response.
+ * Tolerant: handles bare objects, fenced JSON, leading prose, trailing prose.
+ */
+export declare function parseCritiquesResponse(text: string, criticName: string, idPrefix: string): Critique[];

package/dist/iterate/parse.js

@@ -0,0 +1,123 @@
+/**
+ * Parsing helpers for LLM responses in iterate mode.
+ *
+ * We use literal XML-ish markers (<v1_content>…</v1_content>) instead of
+ * pure JSON because LLMs are far more reliable at "write 5000 chars of
+ * markdown then a small JSON block at the end" than at producing one
+ * giant well-formed JSON document with a 5000-char string field.
+ */
+/**
+ * Extract content between `<tag>` and `</tag>`.
+ *
+ * Forgiving in two ways:
+ *  - Case-insensitive on the tag name.
+ *  - If the closing tag is missing (LLM hit max_tokens mid-output), we still
+ *    return everything after the opening tag, stopping at the next sibling
+ *    tag (e.g. the `<merge_rationale>` block) if present, otherwise EOF.
+ */
+export function extractTag(text, tag) {
+    // First try the well-formed case (open + close).
+    const closed = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i");
+    const closedMatch = text.match(closed);
+    if (closedMatch)
+        return closedMatch[1].trim();
+    // Fall back to "open tag without close" — find <tag> and return content
+    // until the next opening tag of any kind, or EOF.
+    const opener = new RegExp(`<${tag}>`, "i");
+    const openMatch = opener.exec(text);
+    if (!openMatch)
+        return null;
+    const after = text.slice(openMatch.index + openMatch[0].length);
+    const nextTag = after.search(/<[a-z_][\w]*>/i);
+    const body = nextTag >= 0 ? after.slice(0, nextTag) : after;
+    return body.trim();
+}
+/** Parse merge response: extract v1 content + rationale. Falls back to whole text if markers are missing. */
+export function parseMergeResponse(text) {
+    const content = extractTag(text, "v1_content");
+    const rationale = extractTag(text, "merge_rationale");
+    if (content) {
+        return { content, rationale: rationale ?? undefined };
+    }
+    // Fallback: no markers — treat whole response as content (with a warning sentinel).
+    return { content: text.trim(), rationale: "[merge markers not found; using full response]" };
+}
+/** Parse revise response: extract content + meta JSON. */
+export function parseReviseResponse(text) {
+    const content = extractTag(text, "v_next_content");
+    const metaRaw = extractTag(text, "v_next_meta");
+    let meta = {};
+    if (metaRaw) {
+        // Strip surrounding code fences if present.
+        const cleaned = metaRaw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
+        try {
+            meta = JSON.parse(cleaned);
+        }
+        catch {
+            meta = { changelog: `[meta JSON parse failed; raw text below]\n${metaRaw}` };
+        }
+    }
+    return {
+        content: content ?? text.trim(),
+        meta,
+    };
+}
+/**
+ * Parse critique JSON from an argue-phase response.
+ * Tolerant: handles bare objects, fenced JSON, leading prose, trailing prose.
+ */
+export function parseCritiquesResponse(text, criticName, idPrefix) {
+    const cleaned = text.replace(/^[^{[]*/, "").replace(/[^}\]]*$/, "").trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(cleaned);
+    }
+    catch {
+        // Try to find the largest JSON object/array in the text.
+        const jsonMatch = text.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+        if (!jsonMatch)
+            return [];
+        try {
+            parsed = JSON.parse(jsonMatch[0]);
+        }
+        catch {
+            return [];
+        }
+    }
+    // Accept either {critiques: [...]} or [...] directly.
+    const arr = Array.isArray(parsed)
+        ? parsed
+        : parsed.critiques;
+    if (!Array.isArray(arr))
+        return [];
+    const out = [];
+    for (let i = 0; i < arr.length; i++) {
+        const c = arr[i];
+        if (!c.anchor || !c.comment)
+            continue;
+        let evidence;
+        if (Array.isArray(c.evidence)) {
+            evidence = c.evidence
+                .filter((e) => {
+                if (typeof e !== "object" || e === null)
+                    return false;
+                const obj = e;
+                return typeof obj.url === "string";
+            })
+                .map((e) => ({ url: e.url, snippet: e.snippet }));
+            if (evidence.length === 0)
+                evidence = undefined;
+        }
+        out.push({
+            id: `${idPrefix}-${criticName}-${i + 1}`,
+            critic: criticName,
+            anchor: String(c.anchor),
+            severity: c.severity ?? "minor",
+            category: c.category ?? "other",
+            comment: String(c.comment),
+            suggestion: c.suggestion ? String(c.suggestion) : undefined,
+            evidence,
+        });
+    }
+    return out;
+}

package/dist/iterate/phases/argue.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Argue phase — critics read a draft and produce critiques in parallel.
+ *
+ * If `enableWebSearch` is on, each critic runs a tool-use loop and may call
+ * web_search / web_fetch up to `maxArgueToolRounds` times before producing
+ * the final critiques JSON. This is the deep-research path that catches
+ * fabricated claims.
+ */
+import type { ArenaParticipant } from "../../types.js";
+import type { FormatPack } from "../formats/index.js";
+import type { Critique, Draft, IterateProgressEvent, IterateSubject } from "../types.js";
+export declare function runArgueRound(args: {
+    subject: IterateSubject;
+    format: FormatPack;
+    draft: Draft;
+    critics: ArenaParticipant[];
+    round: number;
+    enableWebSearch?: boolean;
+    maxToolRounds?: number;
+    signal?: AbortSignal;
+    onProgress?: (e: IterateProgressEvent) => void;
+}): Promise<Critique[]>;

package/dist/iterate/phases/argue.js

@@ -0,0 +1,165 @@
+/**
+ * Argue phase — critics read a draft and produce critiques in parallel.
+ *
+ * If `enableWebSearch` is on, each critic runs a tool-use loop and may call
+ * web_search / web_fetch up to `maxArgueToolRounds` times before producing
+ * the final critiques JSON. This is the deep-research path that catches
+ * fabricated claims.
+ */
+import { createLLMClient } from "@cjhyy/code-shell-core/extension";
+import { logger } from "@cjhyy/code-shell-core/extension";
+import { parseCritiquesResponse } from "../parse.js";
+import { ITERATE_WEB_TOOLS, executeIterateWebTool, hasWebSearchProvider } from "../tools/web-tools.js";
+const DEFAULT_MAX_TOOL_ROUNDS = 8;
+export async function runArgueRound(args) {
+    const { subject, format, draft, critics, round, enableWebSearch, maxToolRounds, signal, onProgress } = args;
+    onProgress?.({ type: "argue_start", round, data: { criticCount: critics.length } });
+    // Web search is only useful if a provider is actually configured. Silently
+    // downgrade if not — log a warning so the user knows.
+    const wantWeb = Boolean(enableWebSearch);
+    const webAvailable = wantWeb && hasWebSearchProvider();
+    if (wantWeb && !webAvailable) {
+        logger.warn("arena.iterate.argue_web_unavailable", {
+            reason: "No SERPER_API_KEY / TAVILY_API_KEY / SEARXNG_URL configured",
+        });
+    }
+    const idPrefix = `r${round}`;
+    const tasks = critics.map(async (c) => {
+        signal?.throwIfAborted();
+        try {
+            if (webAvailable) {
+                return await argueWithToolLoop({
+                    critic: c,
+                    subject,
+                    format,
+                    draft,
+                    idPrefix,
+                    maxToolRounds: maxToolRounds ?? DEFAULT_MAX_TOOL_ROUNDS,
+                    signal,
+                });
+            }
+            return await argueSingleShot({ critic: c, subject, format, draft, idPrefix, signal });
+        }
+        catch (err) {
+            logger.warn("arena.iterate.argue_failed", {
+                round,
+                critic: c.name,
+                error: err.message,
+            });
+            return [];
+        }
+    });
+    const results = await Promise.all(tasks);
+    const allCritiques = results.flat();
+    onProgress?.({
+        type: "argue_done",
+        round,
+        data: { critiqueCount: allCritiques.length, webEnabled: webAvailable },
+    });
+    return allCritiques;
+}
+// ─── Single-shot argue (no tools) ─────────────────────────────────────
+async function argueSingleShot(args) {
+    const { critic, subject, format, draft, idPrefix, signal } = args;
+    const client = await createLLMClient(critic.llm, critic.clientDefaults);
+    const resp = await client.createMessage({
+        systemPrompt: format.argueSystem(format.format),
+        messages: [{ role: "user", content: format.argueUser(subject, draft) }],
+        tools: [],
+        signal,
+    });
+    const critiques = parseCritiquesResponse(resp.text, critic.name, idPrefix);
+    logger.info("arena.iterate.argue_singleshot", {
+        critic: critic.name,
+        critiqueCount: critiques.length,
+    });
+    return critiques;
+}
+// ─── Tool-use argue (with web search) ─────────────────────────────────
+async function argueWithToolLoop(args) {
+    const { critic, subject, format, draft, idPrefix, maxToolRounds, signal } = args;
+    const client = await createLLMClient(critic.llm, critic.clientDefaults);
+    const messages = [
+        { role: "user", content: format.argueUser(subject, draft) },
+    ];
+    let toolRounds = 0;
+    let finalText = "";
+    while (toolRounds < maxToolRounds) {
+        signal?.throwIfAborted();
+        const resp = await client.createMessage({
+            systemPrompt: format.argueSystem(format.format),
+            messages,
+            tools: ITERATE_WEB_TOOLS,
+            signal,
+        });
+        if (resp.text)
+            finalText = resp.text;
+        if (!resp.toolCalls || resp.toolCalls.length === 0) {
+            // Done — final response with critiques JSON.
+            break;
+        }
+        // Append assistant message with tool_use blocks
+        messages.push({
+            role: "assistant",
+            content: [
+                ...(resp.text ? [{ type: "text", text: resp.text }] : []),
+                ...resp.toolCalls.map((tc) => ({
+                    type: "tool_use",
+                    id: tc.id,
+                    name: tc.toolName,
+                    input: tc.args,
+                })),
+            ],
+        });
+        // Execute tools and append tool_result blocks
+        const toolResults = await Promise.all(resp.toolCalls.map(async (tc) => {
+            try {
+                const result = await executeIterateWebTool(tc.toolName, tc.args);
+                return { id: tc.id, content: result };
+            }
+            catch (err) {
+                return { id: tc.id, content: `Error: ${err.message}` };
+            }
+        }));
+        messages.push({
+            role: "user",
+            content: toolResults.map((tr) => ({
+                type: "tool_result",
+                tool_use_id: tr.id,
+                content: tr.content,
+            })),
+        });
+        toolRounds++;
+    }
+    // If we ran out of rounds with no final text, prod the model once more.
+    if (!finalText && toolRounds >= maxToolRounds) {
+        const resp = await client.createMessage({
+            systemPrompt: format.argueSystem(format.format),
+            messages: [
+                ...messages,
+                {
+                    role: "user",
+                    content: "You have used the maximum number of tool rounds. Produce your " +
+                        "critiques JSON now, based on what you have already gathered. " +
+                        "Do not request any more tools.",
+                },
+            ],
+            tools: [],
+            signal,
+        });
+        finalText = resp.text;
+    }
+    if (!finalText) {
+        // Both the tool loop and the force-conclude fallback produced no text
+        // (e.g. repeated max-token truncation). Log it — parseCritiquesResponse
+        // will just yield no critiques rather than silently parsing "".
+        logger.warn("arena.iterate.argue_empty_response", { critic: critic.name, toolRounds });
+    }
+    const critiques = parseCritiquesResponse(finalText, critic.name, idPrefix);
+    logger.info("arena.iterate.argue_toolloop", {
+        critic: critic.name,
+        critiqueCount: critiques.length,
+        toolRounds,
+    });
+    return critiques;
+}

package/dist/iterate/phases/revise.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Revise phase — author rewrites the draft addressing critiques.
+ */
+import type { ArenaParticipant } from "../../types.js";
+import type { FormatPack } from "../formats/index.js";
+import type { Critique, Draft, IterateProgressEvent, IterateSubject } from "../types.js";
+export declare function runRevise(args: {
+    subject: IterateSubject;
+    format: FormatPack;
+    previous: Draft;
+    critiques: Critique[];
+    author: ArenaParticipant;
+    minDraftLength: number;
+    signal?: AbortSignal;
+    onProgress?: (e: IterateProgressEvent) => void;
+}): Promise<Draft>;

package/dist/iterate/phases/revise.js

@@ -0,0 +1,62 @@
+/**
+ * Revise phase — author rewrites the draft addressing critiques.
+ */
+import { createLLMClient } from "@cjhyy/code-shell-core/extension";
+import { logger } from "@cjhyy/code-shell-core/extension";
+import { parseReviseResponse } from "../parse.js";
+export async function runRevise(args) {
+    const { subject, format, previous, critiques, author, minDraftLength, signal, onProgress } = args;
+    onProgress?.({ type: "revise_start", round: previous.version + 1, participant: author.name });
+    const client = await createLLMClient(author.llm, author.clientDefaults);
+    const prompt = format.revisePrompt(subject, previous, critiques, minDraftLength);
+    const resp = await client.createMessage({
+        systemPrompt: prompt,
+        messages: [{ role: "user", content: `Produce v${previous.version + 1} now.` }],
+        tools: [],
+        maxTokens: 32_000,
+        signal,
+    });
+    const { content, meta } = parseReviseResponse(resp.text);
+    // Defensive: refuse to accept a revision that's drastically shorter than v(N) — that's
+    // usually the model collapsing into a summary rather than rewriting.
+    // Accept if shrinkage < 30% OR new content is still above the minimum length.
+    const acceptedContent = content;
+    const shrinkage = previous.content.length > 0
+        ? 1 - acceptedContent.length / previous.content.length
+        : 0;
+    if (shrinkage > 0.3 && acceptedContent.length < minDraftLength) {
+        logger.warn("arena.iterate.revise_too_short", {
+            version: previous.version + 1,
+            previousLength: previous.content.length,
+            newLength: acceptedContent.length,
+            minDraftLength,
+        });
+        // Don't retry automatically — keep going but flag in changelog.
+        meta.changelog =
+            `[WARNING: revision is ${Math.round(shrinkage * 100)}% shorter than v${previous.version}; the author may have summarized instead of rewriting]\n\n` +
+                (meta.changelog ?? "");
+    }
+    const next = {
+        version: previous.version + 1,
+        author: author.name,
+        format: format.format,
+        content: acceptedContent,
+        acceptedCritiques: meta.acceptedCritiques,
+        rejectedCritiques: meta.rejectedCritiques,
+        changelog: meta.changelog,
+    };
+    onProgress?.({
+        type: "revise_done",
+        round: next.version,
+        participant: author.name,
+        data: { length: acceptedContent.length, accepted: meta.acceptedCritiques?.length ?? 0 },
+    });
+    logger.info("arena.iterate.revise", {
+        version: next.version,
+        author: author.name,
+        length: acceptedContent.length,
+        accepted: meta.acceptedCritiques?.length ?? 0,
+        rejected: meta.rejectedCritiques?.length ?? 0,
+    });
+    return next;
+}