@cjhyy/code-shell-arena 0.8.0

package/dist/lenses/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Lens registry — analysis perspectives for Arena sessions.
+ */
+import type { ArenaLens, ArenaLensName, ArenaLensRef } from "../types.js";
+export { engineeringLens } from "./engineering.js";
+export { productLens } from "./product.js";
+export { architectureLens } from "./architecture.js";
+export { generalLens } from "./general.js";
+/** Get a lens by name. */
+export declare function getLens(name: ArenaLensName): ArenaLens;
+/** Resolve lens refs into full ArenaLens objects. */
+export declare function resolveLenses(refs: ArenaLensRef[]): ArenaLens[];
+/** Build a combined lens prompt fragment for participant system prompts. */
+export declare function buildLensPrompt(lenses: ArenaLens[], phase: "participant" | "reviewer" | "moderator"): string;
+/** All available lens names */
+export declare const LENS_NAMES: ArenaLensName[];

package/dist/lenses/index.js

@@ -0,0 +1,47 @@
+/**
+ * Lens registry — analysis perspectives for Arena sessions.
+ */
+import { engineeringLens } from "./engineering.js";
+import { productLens } from "./product.js";
+import { architectureLens } from "./architecture.js";
+import { generalLens } from "./general.js";
+export { engineeringLens } from "./engineering.js";
+export { productLens } from "./product.js";
+export { architectureLens } from "./architecture.js";
+export { generalLens } from "./general.js";
+const LENS_MAP = {
+    engineering: engineeringLens,
+    product: productLens,
+    architecture: architectureLens,
+    general: generalLens,
+};
+/** Get a lens by name. */
+export function getLens(name) {
+    return LENS_MAP[name];
+}
+/** Resolve lens refs into full ArenaLens objects. */
+export function resolveLenses(refs) {
+    return refs.map((ref) => LENS_MAP[ref.name]);
+}
+/** Build a combined lens prompt fragment for participant system prompts. */
+export function buildLensPrompt(lenses, phase) {
+    if (lenses.length === 0)
+        return "";
+    const roleKey = phase === "participant" ? "participantRole"
+        : phase === "reviewer" ? "reviewerRole"
+            : "moderatorRole";
+    const roles = lenses.map((l) => l[roleKey]);
+    const allCriteria = lenses.flatMap((l) => l.criteria);
+    const uniqueCriteria = [...new Set(allCriteria)];
+    const roleDesc = lenses.length === 1
+        ? `You are ${roles[0]}.`
+        : `You combine multiple perspectives: ${roles.join("; ")}.`;
+    return [
+        roleDesc,
+        "",
+        "Evaluation criteria (prioritized):",
+        ...uniqueCriteria.map((c) => `- ${c}`),
+    ].join("\n");
+}
+/** All available lens names */
+export const LENS_NAMES = ["engineering", "product", "architecture", "general"];

package/dist/lenses/product.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Product lens — user value, completeness, edge cases, acceptance criteria.
+ */
+import type { ArenaLens } from "../types.js";
+export declare const productLens: ArenaLens;

package/dist/lenses/product.js

@@ -0,0 +1,22 @@
+/**
+ * Product lens — user value, completeness, edge cases, acceptance criteria.
+ */
+export const productLens = {
+    name: "product",
+    label: "Product",
+    participantRole: "a product analyst focused on user value, completeness, and edge cases",
+    reviewerRole: "a product reviewer evaluating requirements coverage and user impact",
+    moderatorRole: "a product lead synthesizing product perspectives into prioritized insights",
+    summaryLabel: "Product Assessment",
+    criteria: [
+        "Requirements completeness and coverage",
+        "User experience and usability",
+        "Edge cases and boundary conditions",
+        "Acceptance criteria clarity",
+        "Feature scope — too broad or too narrow",
+        "User journey coherence",
+        "Metric and success criteria definition",
+        "Stakeholder alignment",
+    ],
+    preferredFindingKinds: ["question", "improvement", "risk", "strength"],
+};

package/dist/model-presets.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Arena model presets — known models with their max output token limits.
+ *
+ * Used by arena participant resolution to set appropriate maxTokens
+ * so that LLM output is not prematurely truncated.
+ */
+export interface ModelPreset {
+    provider: string;
+    model: string;
+    maxOutputTokens: number;
+}
+export declare const MODEL_PRESETS: Record<string, ModelPreset>;
+/**
+ * Look up max output tokens for a model string, falling back to a safe default.
+ *
+ * Lookup order:
+ *   1. Arena preset key (e.g. "claude", "gpt") — short aliases used in arena UX
+ *   2. Arena preset model path (e.g. "anthropic/claude-opus-4.6")
+ *   3. resolveMaxOutput — the canonical table in onboarding.ts that also covers
+ *      direct-provider IDs (deepseek-v4-pro, …) and OpenRouter snapshot
+ *   4. 8192 — final safe fallback
+ */
+export declare function getMaxOutputTokens(model: string): number;

package/dist/model-presets.js

@@ -0,0 +1,44 @@
+/**
+ * Arena model presets — known models with their max output token limits.
+ *
+ * Used by arena participant resolution to set appropriate maxTokens
+ * so that LLM output is not prematurely truncated.
+ */
+import { resolveMaxOutput } from "@cjhyy/code-shell-core/extension";
+export const MODEL_PRESETS = {
+    claude: { provider: "openai", model: "anthropic/claude-opus-4.6", maxOutputTokens: 32000 },
+    "claude-sonnet": { provider: "openai", model: "anthropic/claude-sonnet-4.6", maxOutputTokens: 16000 },
+    "claude-haiku": { provider: "openai", model: "anthropic/claude-haiku-4.5", maxOutputTokens: 8192 },
+    gpt: { provider: "openai", model: "openai/gpt-5.5", maxOutputTokens: 32000 },
+    "gpt4o": { provider: "openai", model: "openai/gpt-4o", maxOutputTokens: 16384 },
+    o4: { provider: "openai", model: "openai/o4-mini", maxOutputTokens: 100000 },
+    o3: { provider: "openai", model: "openai/o3", maxOutputTokens: 100000 },
+    deepseek: { provider: "openai", model: "deepseek/deepseek-v3.2", maxOutputTokens: 8192 },
+    "deepseek-r1": { provider: "openai", model: "deepseek/deepseek-r1", maxOutputTokens: 8192 },
+    gemini: { provider: "openai", model: "google/gemini-3.1-pro-preview", maxOutputTokens: 65536 },
+    "gemini-2.5": { provider: "openai", model: "google/gemini-2.5-pro", maxOutputTokens: 65536 },
+    "gemini-flash": { provider: "openai", model: "google/gemini-3-flash-preview", maxOutputTokens: 65536 },
+    qwen: { provider: "openai", model: "qwen/qwen3-235b-a22b", maxOutputTokens: 8192 },
+    "qwen-coder": { provider: "openai", model: "qwen/qwen3-coder", maxOutputTokens: 16384 },
+    llama: { provider: "openai", model: "meta-llama/llama-4-maverick", maxOutputTokens: 32000 },
+    devstral: { provider: "openai", model: "mistralai/devstral-medium", maxOutputTokens: 24000 },
+};
+/**
+ * Look up max output tokens for a model string, falling back to a safe default.
+ *
+ * Lookup order:
+ *   1. Arena preset key (e.g. "claude", "gpt") — short aliases used in arena UX
+ *   2. Arena preset model path (e.g. "anthropic/claude-opus-4.6")
+ *   3. resolveMaxOutput — the canonical table in onboarding.ts that also covers
+ *      direct-provider IDs (deepseek-v4-pro, …) and OpenRouter snapshot
+ *   4. 8192 — final safe fallback
+ */
+export function getMaxOutputTokens(model) {
+    const byKey = MODEL_PRESETS[model];
+    if (byKey)
+        return byKey.maxOutputTokens;
+    const byModel = Object.values(MODEL_PRESETS).find((p) => p.model === model);
+    if (byModel)
+        return byModel.maxOutputTokens;
+    return resolveMaxOutput(model) ?? 8192;
+}

package/dist/phases/adjudication.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Adjudication — the moderator makes evidence-based rulings on contested claims.
+ *
+ * For each contested/debated claim, the moderator sees the full claim context
+ * (evidence, challenges, debate rounds) and produces a ClaimAdjudication.
+ *
+ * Claims that were verified without contest get synthetic adjudication records.
+ */
+import type { ArenaParticipant, ArenaStrategy, ClaimAdjudication, ArenaProgressEvent, ArenaUsageRecorder } from "../types.js";
+import type { ArenaLedger } from "../ledger.js";
+interface AdjudicationOptions {
+    concluder: ArenaParticipant;
+    strategy: ArenaStrategy;
+    topic: string;
+    ledger: ArenaLedger;
+    signal?: AbortSignal;
+    onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
+}
+/**
+ * Run adjudication phase. The moderator rules on contested claims.
+ * Verified claims get synthetic adjudications.
+ */
+export declare function runAdjudication(options: AdjudicationOptions): Promise<ClaimAdjudication[]>;
+export {};

package/dist/phases/adjudication.js

@@ -0,0 +1,142 @@
+/**
+ * Adjudication — the moderator makes evidence-based rulings on contested claims.
+ *
+ * For each contested/debated claim, the moderator sees the full claim context
+ * (evidence, challenges, debate rounds) and produces a ClaimAdjudication.
+ *
+ * Claims that were verified without contest get synthetic adjudication records.
+ */
+import { createLLMClient } from "@cjhyy/code-shell-core/extension";
+import { isStrategyV2 } from "../types.js";
+import { buildDigest } from "../digest-builder.js";
+import { transitionClaim, markUnresolved } from "../transitions.js";
+import { parseAdjudication as parseAdjudicationUtil } from "../strategies/utils.js";
+import { logger } from "@cjhyy/code-shell-core/extension";
+/**
+ * Run adjudication phase. The moderator rules on contested claims.
+ * Verified claims get synthetic adjudications.
+ */
+export async function runAdjudication(options) {
+    const { concluder, strategy, topic, ledger, signal, onProgress, onUsage } = options;
+    const allAdjudications = [];
+    const v2 = isStrategyV2(strategy);
+    // Claims that need moderator adjudication: contested or those with debate rounds
+    const contestedClaims = ledger.getClaimsByStatus("contested");
+    // Claims that were verified cleanly — synthetic adjudication
+    const verifiedClaims = ledger.getClaimsByStatus("verified");
+    if (contestedClaims.length === 0 && verifiedClaims.length === 0) {
+        logger.info("arena.adjudication_skip", { reason: "no claims to adjudicate" });
+        return [];
+    }
+    logger.info("arena.adjudication_start", {
+        contested: contestedClaims.length,
+        verified: verifiedClaims.length,
+    });
+    // Adjudicate contested claims via LLM
+    const client = await createLLMClient(concluder.llm, concluder.clientDefaults);
+    for (const claim of contestedClaims) {
+        signal?.throwIfAborted();
+        const digest = buildDigest(ledger, {
+            round: 0, // adjudication is post-debate
+            relevantClaimIds: [claim.claimId],
+        });
+        const systemPrompt = strategy.consensusSystemPrompt();
+        let userContent;
+        if (v2) {
+            userContent = strategy
+                .adjudicationUserPrompt(topic, claim, claim.debateRounds, digest);
+        }
+        else {
+            userContent = buildFallbackAdjudicationPrompt(topic, claim);
+        }
+        const response = await client.createMessage({
+            systemPrompt,
+            messages: [{ role: "user", content: userContent }],
+            signal,
+        });
+        onUsage?.(response.usage);
+        logger.info("arena.adjudication_response", {
+            claimId: claim.claimId,
+            stopReason: response.stopReason,
+        });
+        let adjudication;
+        if (v2) {
+            adjudication = strategy.parseAdjudicationResponse(response.text);
+            adjudication.claimId = claim.claimId;
+        }
+        else {
+            adjudication = parseAdjudicationUtil(claim.claimId, response.text);
+        }
+        // Record in ledger
+        ledger.appendAdjudication(adjudication);
+        allAdjudications.push(adjudication);
+        // Transition claim based on outcome
+        applyAdjudicationOutcome(claim, adjudication);
+    }
+    // Synthetic adjudications for verified claims
+    for (const claim of verifiedClaims) {
+        const adjudication = {
+            claimId: claim.claimId,
+            outcome: "accepted",
+            rationale: "Verified by peer review without contest",
+            finalSummary: claim.finding.summary,
+            supportingEvidenceRefs: claim.evidenceRefs,
+        };
+        ledger.appendAdjudication(adjudication);
+        allAdjudications.push(adjudication);
+    }
+    // Any remaining proposed/under_review claims → mark unresolved
+    const remaining = ledger.getClaimsByStatus("proposed", "under_review");
+    for (const claim of remaining) {
+        markUnresolved(claim);
+    }
+    const accepted = allAdjudications.filter((a) => a.outcome === "accepted" || a.outcome === "accepted_with_revision").length;
+    const unresolved = ledger.getClaimsByStatus("unresolved").length;
+    logger.info("arena.adjudication_done", {
+        total: allAdjudications.length,
+        accepted,
+        unresolved,
+    });
+    onProgress?.({ type: "adjudication_done", accepted, unresolved });
+    return allAdjudications;
+}
+/**
+ * Apply adjudication outcome to claim status.
+ */
+function applyAdjudicationOutcome(claim, adjudication) {
+    switch (adjudication.outcome) {
+        case "accepted":
+        case "accepted_with_revision":
+            transitionClaim(claim, "verified");
+            break;
+        case "rejected":
+            transitionClaim(claim, "rejected");
+            break;
+        case "unresolved":
+            markUnresolved(claim);
+            break;
+    }
+}
+/**
+ * Build a fallback adjudication prompt for non-V2 strategies.
+ */
+function buildFallbackAdjudicationPrompt(topic, claim) {
+    const challengeText = claim.challenges.length > 0
+        ? claim.challenges.map((c) => `[${c.reviewer}] ${c.verdict}: ${c.reason}`).join("\n")
+        : "No challenges.";
+    const debateText = claim.debateRounds.length > 0
+        ? claim.debateRounds.map((r) => `Round ${r.round}:\n` +
+            r.participants.map((t) => `  [${t.participant}] ${t.stance}: ${t.summary}`).join("\n") +
+            `\n  ${r.resolved ? "→ Resolved" : "→ Unresolved"}`).join("\n\n")
+        : "No debate rounds.";
+    return (`## Topic: ${topic}\n\n` +
+        `## Claim Under Adjudication\n` +
+        `[${claim.claimId}] ${claim.finding.title}\n${claim.finding.summary}\n` +
+        `Owner: ${claim.owner} | Status: ${claim.status}\n\n` +
+        `## Challenges\n${challengeText}\n\n` +
+        `## Debate\n${debateText}\n\n` +
+        `As moderator, adjudicate this claim based on all available evidence.\n` +
+        `Respond ONLY with JSON:\n` +
+        `{"outcome": "accepted|accepted_with_revision|rejected|unresolved", "rationale": "...", ` +
+        `"finalSummary": "revised claim summary if needed", "supportingEvidenceRefs": ["..."]}`);
+}

package/dist/phases/build-consensus.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ConsensusBuilder — aggregates findings + peer reviews into structured consensus.
+ *
+ * V1: Program aggregates finding + review data, moderator LLM organizes.
+ * V2: When claim data is available, uses claim-aware prompts that distinguish
+ *     verified/unresolved/rejected claims.
+ *
+ * In both paths, the moderator must faithfully reflect aggregated results
+ * (no new unsourced conclusions).
+ */
+import type { ArenaParticipant, ArenaStrategy, ParticipantReport, FindingReview, ArenaConsensus, ClaimStatusSummary, ArenaProgressEvent, ArenaUsageRecorder } from "../types.js";
+interface ConsensusOptions {
+    /** The participant that acts as moderator/concluder */
+    concluder: ArenaParticipant;
+    strategy: ArenaStrategy;
+    topic: string;
+    reports: ParticipantReport[];
+    reviews: FindingReview[];
+    /** Claim status summary — when provided, enables claim-aware consensus (V2) */
+    claimSummary?: ClaimStatusSummary;
+    signal?: AbortSignal;
+    onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
+}
+/**
+ * Build structured consensus from participant reports, cross-reviews,
+ * and optionally adjudicated claim data.
+ */
+export declare function buildConsensus(options: ConsensusOptions): Promise<ArenaConsensus>;
+export {};

package/dist/phases/build-consensus.js

@@ -0,0 +1,85 @@
+/**
+ * ConsensusBuilder — aggregates findings + peer reviews into structured consensus.
+ *
+ * V1: Program aggregates finding + review data, moderator LLM organizes.
+ * V2: When claim data is available, uses claim-aware prompts that distinguish
+ *     verified/unresolved/rejected claims.
+ *
+ * In both paths, the moderator must faithfully reflect aggregated results
+ * (no new unsourced conclusions).
+ */
+import { createLLMClient } from "@cjhyy/code-shell-core/extension";
+import { logger } from "@cjhyy/code-shell-core/extension";
+import { isStrategyV2 } from "../types.js";
+/**
+ * Build structured consensus from participant reports, cross-reviews,
+ * and optionally adjudicated claim data.
+ */
+export async function buildConsensus(options) {
+    const { concluder, strategy, topic, reports, reviews, claimSummary, signal, onProgress, onUsage } = options;
+    onProgress?.({ type: "consensus_start" });
+    const client = await createLLMClient(concluder.llm, concluder.clientDefaults);
+    const systemPrompt = strategy.consensusSystemPrompt();
+    // Choose user prompt: claim-aware (V2) or standard (V1)
+    let userContent;
+    const v2 = isStrategyV2(strategy);
+    if (v2 && claimSummary) {
+        userContent = strategy
+            .claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary);
+        logger.info("arena.consensus_claim_aware", {
+            verified: claimSummary.verified.length,
+            unresolved: claimSummary.unresolved.length,
+            contested: claimSummary.contested.length,
+            rejected: claimSummary.rejected.length,
+        });
+    }
+    else {
+        userContent = strategy.consensusUserPrompt(topic, reports, reviews);
+    }
+    const response = await client.createMessage({
+        systemPrompt,
+        messages: [{ role: "user", content: userContent }],
+        signal,
+    });
+    onUsage?.(response.usage);
+    logger.info("arena.consensus_raw_response", {
+        text: response.text,
+        stopReason: response.stopReason,
+    });
+    // If output was truncated by max_tokens, retry with a condensed prompt
+    if (response.stopReason === "length") {
+        logger.warn("arena.consensus_truncated", {
+            textLen: response.text?.length ?? 0,
+            maxTokens: concluder.llm.maxTokens,
+        });
+        const retryResponse = await client.createMessage({
+            systemPrompt,
+            messages: [
+                { role: "user", content: userContent },
+                { role: "assistant", content: response.text },
+                {
+                    role: "user",
+                    content: "Your previous response was truncated. Please output a COMPLETE but more concise version of the consensus JSON. " +
+                        "Keep all sections but use shorter summaries. Respond ONLY with the complete JSON object.",
+                },
+            ],
+            signal,
+        });
+        onUsage?.(retryResponse.usage);
+        logger.info("arena.consensus_retry_response", {
+            textLen: retryResponse.text?.length ?? 0,
+            stopReason: retryResponse.stopReason,
+        });
+        if (retryResponse.stopReason === "length") {
+            logger.warn("arena.consensus_still_truncated", {
+                textLen: retryResponse.text?.length ?? 0,
+            });
+        }
+        const consensus = strategy.parseConsensusResponse(retryResponse.text);
+        onProgress?.({ type: "consensus_done", consensus });
+        return consensus;
+    }
+    const consensus = strategy.parseConsensusResponse(response.text);
+    onProgress?.({ type: "consensus_done", consensus });
+    return consensus;
+}

package/dist/phases/claim-registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ClaimRegistry — converts ResearchDossier findings into ClaimRecords.
+ *
+ * Each finding is elevated to a claim with:
+ * - Stable global ID (owner + finding.id)
+ * - Evidence packet references from findingEvidenceLinks
+ * - Initial status: "proposed"
+ */
+import type { ResearchDossier, ClaimRecord, ArenaProgressEvent } from "../types.js";
+import type { ArenaLedger } from "../ledger.js";
+interface ClaimRegistryOptions {
+    dossiers: ResearchDossier[];
+    ledger: ArenaLedger;
+    onProgress?: (event: ArenaProgressEvent) => void;
+}
+/**
+ * Register all findings from research dossiers as claims.
+ * Returns the newly created ClaimRecord array.
+ */
+export declare function registerClaims(options: ClaimRegistryOptions): ClaimRecord[];
+/**
+ * Select claims for review, prioritized by severity and confidence.
+ * Respects the maxClaimsForReview limit.
+ */
+export declare function selectClaimsForReview(claims: ClaimRecord[], maxClaims: number): ClaimRecord[];
+export {};

package/dist/phases/claim-registry.js

@@ -0,0 +1,60 @@
+/**
+ * ClaimRegistry — converts ResearchDossier findings into ClaimRecords.
+ *
+ * Each finding is elevated to a claim with:
+ * - Stable global ID (owner + finding.id)
+ * - Evidence packet references from findingEvidenceLinks
+ * - Initial status: "proposed"
+ */
+/**
+ * Register all findings from research dossiers as claims.
+ * Returns the newly created ClaimRecord array.
+ */
+export function registerClaims(options) {
+    const { dossiers, ledger, onProgress } = options;
+    const claims = [];
+    for (const dossier of dossiers) {
+        // Build a lookup from findingId → evidencePacketIds
+        const linkMap = new Map();
+        for (const link of dossier.findingEvidenceLinks) {
+            linkMap.set(link.findingId, link.evidencePacketIds);
+        }
+        for (const finding of dossier.findings) {
+            const claimId = `${dossier.participant}:${finding.id}`;
+            const packetIds = linkMap.get(finding.id) ?? [];
+            // Build evidence refs from finding.evidence + packet refs
+            const evidenceRefs = finding.evidence.map((e) => `${e.type}:${e.ref}`);
+            const claim = {
+                claimId,
+                owner: dossier.participant,
+                finding,
+                evidenceRefs,
+                evidencePacketIds: packetIds,
+                status: "proposed",
+                challenges: [],
+                debateRounds: [],
+            };
+            claims.push(claim);
+            ledger.appendClaim(claim);
+        }
+    }
+    onProgress?.({ type: "claims_registered", claimCount: claims.length });
+    return claims;
+}
+/**
+ * Select claims for review, prioritized by severity and confidence.
+ * Respects the maxClaimsForReview limit.
+ */
+export function selectClaimsForReview(claims, maxClaims) {
+    const severityOrder = { high: 0, medium: 1, low: 2 };
+    const sorted = [...claims].sort((a, b) => {
+        // Higher severity first
+        const sevA = severityOrder[a.finding.severity ?? "medium"] ?? 1;
+        const sevB = severityOrder[b.finding.severity ?? "medium"] ?? 1;
+        if (sevA !== sevB)
+            return sevA - sevB;
+        // Higher confidence first
+        return b.finding.confidence - a.finding.confidence;
+    });
+    return sorted.slice(0, maxClaims);
+}

package/dist/phases/cross-review.d.ts

@@ -0,0 +1,47 @@
+/**
+ * CrossReview / VerificationReview — participants review each other's findings.
+ *
+ * V1 (CrossReview): Each participant sees the other participants' structured findings
+ * and provides per-finding verdicts: agree, refine, disagree, needs_evidence.
+ *
+ * V2 (VerificationReview): Reviewers get claim + evidence packet + digest data,
+ * and produce ClaimChallenge records that feed into the claim state machine.
+ */
+import type { ArenaParticipant, ArenaStrategy, ParticipantReport, FindingReview, ClaimChallenge, ArenaProgressEvent, ArenaExecutionLimits, ArenaUsageRecorder } from "../types.js";
+import type { ArenaLedger } from "../ledger.js";
+interface CrossReviewOptions {
+    participants: ArenaParticipant[];
+    strategy: ArenaStrategy;
+    topic: string;
+    reports: ParticipantReport[];
+    signal?: AbortSignal;
+    onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
+}
+/**
+ * Run cross-review phase (V1). Each participant reviews the others' findings.
+ */
+export declare function runCrossReview(options: CrossReviewOptions): Promise<FindingReview[]>;
+interface VerificationReviewOptions {
+    participants: ArenaParticipant[];
+    strategy: ArenaStrategy;
+    topic: string;
+    reports: ParticipantReport[];
+    ledger: ArenaLedger;
+    limits: ArenaExecutionLimits;
+    /** Arena mode — planning routes to merge-oriented review */
+    mode?: "review" | "discussion" | "planning";
+    signal?: AbortSignal;
+    onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
+}
+interface VerificationReviewResult {
+    reviews: FindingReview[];
+    challenges: ClaimChallenge[];
+}
+/**
+ * Run verification-review phase. Reviewers get claim + evidence + digest data.
+ * Falls back to V1 cross-review if strategy doesn't implement V2.
+ */
+export declare function runVerificationReview(options: VerificationReviewOptions): Promise<VerificationReviewResult>;
+export {};