@cjhyy/code-shell-core 0.7.1 → 0.8.0

package/dist/arena/phases/adjudication.js

@@ -1,142 +0,0 @@
-/**
- * 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 "../../llm/client-factory.js";
-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 "../../logging/logger.js";
-/**
- * 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/arena/phases/build-consensus.d.ts

@@ -1,30 +0,0 @@
-/**
- * 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/arena/phases/build-consensus.js

@@ -1,85 +0,0 @@
-/**
- * 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 "../../llm/client-factory.js";
-import { logger } from "../../logging/logger.js";
-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/arena/phases/claim-registry.d.ts

@@ -1,26 +0,0 @@
-/**
- * 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/arena/phases/claim-registry.js

@@ -1,60 +0,0 @@
-/**
- * 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/arena/phases/cross-review.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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 {};

package/dist/arena/phases/cross-review.js

@@ -1,224 +0,0 @@
-/**
- * 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 { createLLMClient } from "../../llm/client-factory.js";
-import { isStrategyV2, isStrategyPlanning } from "../types.js";
-import { selectClaimsForReview } from "./claim-registry.js";
-import { buildDigest } from "../digest-builder.js";
-import { markUnderReview, applyReviewResult } from "../transitions.js";
-import { logger } from "../../logging/logger.js";
-/**
- * Run cross-review phase (V1). Each participant reviews the others' findings.
- */
-export async function runCrossReview(options) {
-    const { participants, strategy, topic, reports, signal, onProgress, onUsage } = options;
-    onProgress?.({ type: "cross_review_start", round: 1 });
-    const allReviews = [];
-    const tasks = participants.map(async (p) => {
-        const myReport = reports.find((r) => r.participant === p.name);
-        const otherReports = reports.filter((r) => r.participant !== p.name);
-        // Skip if no other reports to review
-        if (otherReports.length === 0)
-            return [];
-        if (!myReport)
-            return [];
-        const client = await createLLMClient(p.llm, p.clientDefaults);
-        const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
-        const userContent = strategy.crossReviewUserPrompt(topic, myReport, otherReports);
-        let response = await client.createMessage({
-            systemPrompt,
-            messages: [{ role: "user", content: userContent }],
-            signal,
-        });
-        onUsage?.(response.usage);
-        logger.info("arena.cross_review_raw_response", {
-            participant: p.name,
-            text: response.text,
-            stopReason: response.stopReason,
-        });
-        // Retry if truncated
-        if (response.stopReason === "length") {
-            logger.warn("arena.cross_review_truncated", { participant: p.name });
-            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 the COMPLETE review JSON, using shorter comments. Respond ONLY with JSON.",
-                    },
-                ],
-                signal,
-            });
-            onUsage?.(retryResponse.usage);
-            logger.info("arena.cross_review_retry", {
-                participant: p.name,
-                stopReason: retryResponse.stopReason,
-            });
-            response = retryResponse;
-        }
-        return strategy.parseCrossReviewResponse(p.name, response.text);
-    });
-    const results = await Promise.all(tasks);
-    for (const reviews of results) {
-        allReviews.push(...reviews);
-    }
-    onProgress?.({ type: "cross_review_done", reviews: allReviews });
-    return allReviews;
-}
-/**
- * Run verification-review phase. Reviewers get claim + evidence + digest data.
- * Falls back to V1 cross-review if strategy doesn't implement V2.
- */
-export async function runVerificationReview(options) {
-    const { participants, strategy, topic, reports, ledger, limits, mode, signal, onProgress, onUsage } = options;
-    // Select claims to review, prioritized by severity + confidence
-    const allClaims = ledger.getAllClaims();
-    const claimsToReview = selectClaimsForReview(allClaims, limits.maxClaimsForReview);
-    // Transition selected claims to under_review
-    for (const claim of claimsToReview) {
-        markUnderReview(claim);
-    }
-    // Build digest for reviewer context
-    const relevantClaimIds = claimsToReview.map((c) => c.claimId);
-    const digest = buildDigest(ledger, { round: 1, relevantClaimIds });
-    const isPlanningMerge = mode === "planning" && isStrategyPlanning(strategy);
-    if (isPlanningMerge) {
-        onProgress?.({ type: "planning_merge_review_start" });
-    }
-    else {
-        onProgress?.({ type: "verification_start" });
-    }
-    const v2 = isStrategyV2(strategy);
-    const allReviews = [];
-    const allChallenges = [];
-    // Assign claims to reviewers: each claim reviewed by non-owners, capped
-    const tasks = participants.map(async (p) => {
-        const myReport = reports.find((r) => r.participant === p.name);
-        const otherReports = reports.filter((r) => r.participant !== p.name);
-        if (!myReport || otherReports.length === 0)
-            return;
-        // Claims this participant should review (not their own)
-        const myClaims = claimsToReview.filter((c) => c.owner !== p.name);
-        if (myClaims.length === 0)
-            return;
-        const client = await createLLMClient(p.llm, p.clientDefaults);
-        const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
-        if (v2) {
-            // V2 path: claim-aware verification review (or merge review for planning)
-            const userContent = isPlanningMerge
-                ? strategy.mergeReviewUserPrompt(topic, myReport, myClaims, digest)
-                : strategy
-                    .verificationReviewUserPrompt(topic, myReport, myClaims, digest);
-            let response = await client.createMessage({
-                systemPrompt,
-                messages: [{ role: "user", content: userContent }],
-                signal,
-            });
-            onUsage?.(response.usage);
-            logger.info("arena.verification_review_raw", {
-                participant: p.name,
-                stopReason: response.stopReason,
-            });
-            if (response.stopReason === "length") {
-                const retryResponse = await client.createMessage({
-                    systemPrompt,
-                    messages: [
-                        { role: "user", content: userContent },
-                        { role: "assistant", content: response.text },
-                        { role: "user", content: "Truncated. Output the COMPLETE JSON array, shorter comments. JSON only." },
-                    ],
-                    signal,
-                });
-                onUsage?.(retryResponse.usage);
-                response = retryResponse;
-            }
-            const challenges = isPlanningMerge
-                ? strategy.parseMergeReviewResponse(p.name, response.text)
-                : strategy
-                    .parseVerificationReviewResponse(p.name, response.text);
-            for (const challenge of challenges) {
-                allChallenges.push(challenge);
-                ledger.appendChallenge(challenge);
-            }
-            // Also produce FindingReview for backward compat
-            for (const ch of challenges) {
-                allReviews.push({
-                    reviewer: ch.reviewer,
-                    findingId: ch.claimId,
-                    verdict: ch.verdict,
-                    reason: ch.reason,
-                    extraEvidence: ch.supportingEvidenceRefs,
-                });
-            }
-        }
-        else {
-            // V1 fallback: standard cross-review, then map to challenges
-            const userContent = strategy.crossReviewUserPrompt(topic, myReport, otherReports);
-            let response = await client.createMessage({
-                systemPrompt,
-                messages: [{ role: "user", content: userContent }],
-                signal,
-            });
-            onUsage?.(response.usage);
-            if (response.stopReason === "length") {
-                const retryResponse = await client.createMessage({
-                    systemPrompt,
-                    messages: [
-                        { role: "user", content: userContent },
-                        { role: "assistant", content: response.text },
-                        { role: "user", content: "Truncated. Output COMPLETE review JSON. Shorter comments. JSON only." },
-                    ],
-                    signal,
-                });
-                onUsage?.(retryResponse.usage);
-                response = retryResponse;
-            }
-            const reviews = strategy.parseCrossReviewResponse(p.name, response.text);
-            allReviews.push(...reviews);
-            // Map FindingReview → ClaimChallenge for claim state updates
-            for (const review of reviews) {
-                // Find the claim that matches this finding
-                const claim = claimsToReview.find((c) => c.finding.id === review.findingId || c.claimId === review.findingId);
-                if (claim) {
-                    const challenge = {
-                        reviewer: review.reviewer,
-                        claimId: claim.claimId,
-                        verdict: review.verdict,
-                        reason: review.reason,
-                        supportingEvidenceRefs: review.extraEvidence,
-                    };
-                    allChallenges.push(challenge);
-                    ledger.appendChallenge(challenge);
-                }
-            }
-        }
-    });
-    await Promise.all(tasks);
-    // Apply review results to claim status transitions
-    for (const claim of claimsToReview) {
-        const claimChallenges = ledger.getChallengesForClaim(claim.claimId);
-        const hasPendingChecks = ledger.getPendingChecksForClaim(claim.claimId).length > 0;
-        applyReviewResult(claim, claimChallenges, hasPendingChecks);
-    }
-    logger.info("arena.verification_done", {
-        reviewCount: allReviews.length,
-        challengeCount: allChallenges.length,
-        claimStatuses: Object.fromEntries(claimsToReview.map((c) => [c.claimId, c.status])),
-    });
-    if (isPlanningMerge) {
-        onProgress?.({ type: "planning_merge_review_done", mergeCount: allChallenges.length });
-    }
-    else {
-        onProgress?.({ type: "verification_done", challengeCount: allChallenges.length });
-    }
-    onProgress?.({ type: "cross_review_done", reviews: allReviews });
-    return { reviews: allReviews, challenges: allChallenges };
-}

package/dist/arena/phases/debate-rounds.d.ts

@@ -1,28 +0,0 @@
-/**
- * DebateRounds — contested claims enter structured debate between
- * the claim owner and the primary challenger.
- *
- * Each debate round:
- *   1. Both debaters produce a DebateTurn (stance + argument)
- *   2. Convergence check: all stances are "support" or "narrow" → resolved
- *   3. If max rounds exhausted → stays contested for adjudication
- */
-import type { ArenaParticipant, ArenaStrategy, DebateRound, ArenaExecutionLimits, ArenaProgressEvent, ArenaUsageRecorder } from "../types.js";
-import type { ArenaLedger } from "../ledger.js";
-interface DebateOptions {
-    participants: ArenaParticipant[];
-    strategy: ArenaStrategy;
-    topic: string;
-    ledger: ArenaLedger;
-    limits: ArenaExecutionLimits;
-    maxRounds: number;
-    signal?: AbortSignal;
-    onProgress?: (event: ArenaProgressEvent) => void;
-    onUsage?: ArenaUsageRecorder;
-}
-/**
- * Run debate rounds for all contested claims.
- * Returns empty array if no contested claims exist.
- */
-export declare function runDebateRounds(options: DebateOptions): Promise<DebateRound[]>;
-export {};