@cjhyy/code-shell-core 0.7.1 → 0.8.1

package/dist/arena/iterate/types.d.ts

@@ -1,152 +0,0 @@
-/**
- * Iterate mode — multi-model authoring loop.
- *
- * Author writes → critics argue → author revises → ... → final draft.
- * v1 uses a tournament: every participant writes a candidate, then the
- * author merges (anonymized inputs) into a single v1.
- */
-import type { ArenaParticipant } from "../types.js";
-export type IterateFormat = "code" | "document";
-export interface IterateSubject {
-    /** What the author is producing — short descriptive label. */
-    label: string;
-    /** Full instruction to the author / critics. */
-    description: string;
-    /** Optional source artifacts (file paths, urls) to ground the work. */
-    sources?: string[];
-}
-/** A v1 candidate produced by one participant during the tournament. */
-export interface DraftCandidate {
-    author: string;
-    anonymousLabel: string;
-    content: string;
-}
-export interface Draft {
-    version: number;
-    author: string;
-    format: IterateFormat;
-    content: string;
-    /**
-     * For v1 with tournament strategy: the candidates that were merged.
-     * For v2+: undefined.
-     */
-    draftCandidates?: DraftCandidate[];
-    /** Author's explanation of how candidates were merged into v1. */
-    mergeRationale?: string;
-    /**
-     * For v2+: which critique IDs were addressed and how.
-     */
-    acceptedCritiques?: string[];
-    rejectedCritiques?: Array<{
-        id: string;
-        reason: string;
-    }>;
-    /** Free-form note from author: what changed and why. */
-    changelog?: string;
-}
-export type CritiqueSeverity = "blocker" | "major" | "minor" | "nit" | "praise";
-export type CritiqueCategory = "correctness" | "completeness" | "clarity" | "evidence" | "structure" | "style" | "fabrication" | "other";
-export interface CritiqueEvidence {
-    url: string;
-    snippet?: string;
-}
-export interface Critique {
-    id: string;
-    critic: string;
-    /** 5-15 word quote from the draft for precise location. */
-    anchor: string;
-    severity: CritiqueSeverity;
-    category: CritiqueCategory;
-    comment: string;
-    /** Optional concrete suggestion. */
-    suggestion?: string;
-    /** Optional URLs the critic consulted to back up the critique. */
-    evidence?: CritiqueEvidence[];
-}
-export interface ConvergenceSignal {
-    blockerCount: number;
-    majorCount: number;
-    totalCritiques: number;
-    /** Levenshtein-ratio-like 0..1, where 0 = identical, 1 = totally different. */
-    diffFromPrevious: number;
-    shouldStop: boolean;
-    reason: "blockers_zero_and_stable" | "all_minor_or_praise" | "max_rounds" | "user_stop" | "user_force_continue" | "diff_below_threshold" | "running";
-}
-export interface Round {
-    round: number;
-    draft: Draft;
-    critiques: Critique[];
-    convergence: ConvergenceSignal;
-}
-export type AuthorRotation = "fixed" | "round-robin" | "best-critic";
-export interface CheckpointContext {
-    round: number;
-    draft: Draft;
-    critiques: Critique[];
-    convergence: ConvergenceSignal;
-}
-export type CheckpointAction = "continue" | "stop" | "force-continue";
-export type CheckpointFn = (ctx: CheckpointContext) => Promise<CheckpointAction>;
-export interface IterateProgressEvent {
-    type: "v1_tournament_start" | "v1_candidate_done" | "v1_merge_start" | "v1_merge_done" | "round_start" | "argue_start" | "argue_done" | "revise_start" | "revise_done" | "round_done" | "checkpoint_pause" | "iterate_complete";
-    round?: number;
-    participant?: string;
-    data?: Record<string, unknown>;
-}
-export interface IterateConfig {
-    subject: IterateSubject;
-    format: IterateFormat;
-    /** The participant who merges v1 and main-authors v2+. Required. */
-    author: ArenaParticipant;
-    /** Critic participants. Each must have unique `name`. */
-    critics: ArenaParticipant[];
-    /** Default 5. */
-    maxRounds?: number;
-    /**
-     * v1 strategy.
-     * - "tournament" (default): author + all critics each write a candidate,
-     *    author merges anonymized candidates into v1.
-     * - "single": author writes v1 alone (no tournament).
-     */
-    v1Strategy?: "tournament" | "single";
-    /** Default "fixed". */
-    authorRotation?: AuthorRotation;
-    /**
-     * If provided, called after each round; arena pauses for the response.
-     * Default: undefined (no checkpoints).
-     */
-    humanCheckpoint?: CheckpointFn;
-    /**
-     * Convergence rules. "default" applies built-in heuristics.
-     * Custom function returns true → stop after this round.
-     */
-    convergenceStrategy?: "default" | ((ctx: {
-        round: number;
-        critiques: Critique[];
-        draft: Draft;
-        previousDraft?: Draft;
-    }) => boolean);
-    /** Minimum content length per draft (chars). Used both as length budget hint and to retry-on-shrinkage. Default 800 for document, 200 for code. */
-    minDraftLength?: number;
-    /**
-     * Whether critics get web_search/web_fetch tools during the argue phase.
-     * Requires SERPER_API_KEY / TAVILY_API_KEY / SEARXNG_URL in env. Default false.
-     * When true, each argue call becomes a tool-use loop (critics may search
-     * before producing critiques) — significantly more tokens and time, but
-     * dramatically reduces fabrication.
-     */
-    enableWebSearch?: boolean;
-    /** Cap tool-use rounds per critic per argue phase. Default 8. */
-    maxArgueToolRounds?: number;
-    signal?: AbortSignal;
-    onProgress?: (event: IterateProgressEvent) => void;
-}
-export type StoppedReason = "converged" | "max_rounds" | "user_stop" | "errored" | "aborted";
-export interface IterateResult {
-    subject: IterateSubject;
-    format: IterateFormat;
-    rounds: Round[];
-    finalDraft: Draft;
-    stoppedAt: StoppedReason;
-    durationMs: number;
-}

package/dist/arena/iterate/types.js

@@ -1,8 +0,0 @@
-/**
- * Iterate mode — multi-model authoring loop.
- *
- * Author writes → critics argue → author revises → ... → final draft.
- * v1 uses a tournament: every participant writes a candidate, then the
- * author merges (anonymized inputs) into a single v1.
- */
-export {};

package/dist/arena/ledger.d.ts

@@ -1,47 +0,0 @@
-/**
- * SharedResearchLedger — append-only shared state across all arena rounds.
- *
- * Design constraints (from architecture doc):
- * - All objects have stable IDs
- * - Append-only: history preserved, never overwritten
- * - Query layer supports latest-view aggregation
- * - Supports by-id, by-claim, by-participant, by-round filtering
- */
-import type { SharedResearchLedger, ResearchDossier, EvidencePacket, ClaimRecord, ClaimChallenge, RequestedCheck, ClaimAdjudication } from "./types.js";
-/**
- * Manages the shared research ledger — the single source of truth
- * for all evidence, claims, challenges, and adjudications in an arena session.
- */
-export declare class ArenaLedger {
-    private ledger;
-    private index;
-    constructor();
-    /** Check if ledger is approaching memory limits and log warnings */
-    private checkGrowth;
-    appendDossier(dossier: ResearchDossier): void;
-    appendEvidencePacket(packet: EvidencePacket): void;
-    appendClaim(claim: ClaimRecord): void;
-    appendChallenge(challenge: ClaimChallenge): void;
-    appendRequestedCheck(check: RequestedCheck): void;
-    appendAdjudication(adjudication: ClaimAdjudication): void;
-    /**
-     * Return a read-only reference to the full ledger.
-     *
-     * Note: `Readonly<>` is shallow — inner arrays are still mutable at the
-     * type level. Callers MUST NOT mutate the returned object; use the
-     * append* methods instead. A deep-freeze or structural clone can be
-     * added later if external consumers need a truly immutable snapshot.
-     */
-    getSnapshot(): Readonly<SharedResearchLedger>;
-    getClaimById(claimId: string): ClaimRecord | undefined;
-    getPacketById(packetId: string): EvidencePacket | undefined;
-    getAllClaims(): ClaimRecord[];
-    getClaimsByStatus(...statuses: ClaimRecord["status"][]): ClaimRecord[];
-    getClaimsByOwner(owner: string): ClaimRecord[];
-    getChallengesForClaim(claimId: string): ClaimChallenge[];
-    getPendingChecks(): RequestedCheck[];
-    getPendingChecksForClaim(claimId: string): RequestedCheck[];
-    getPacketsForClaim(claimId: string): EvidencePacket[];
-    getDossiers(): ResearchDossier[];
-    getDossierByParticipant(participant: string): ResearchDossier | undefined;
-}

package/dist/arena/ledger.js

@@ -1,159 +0,0 @@
-/**
- * SharedResearchLedger — append-only shared state across all arena rounds.
- *
- * Design constraints (from architecture doc):
- * - All objects have stable IDs
- * - Append-only: history preserved, never overwritten
- * - Query layer supports latest-view aggregation
- * - Supports by-id, by-claim, by-participant, by-round filtering
- */
-import { logger } from "../logging/logger.js";
-/** Thresholds for memory warnings */
-const WARN_CLAIMS = 50;
-const WARN_PACKETS = 200;
-const WARN_CHALLENGES = 100;
-/**
- * Manages the shared research ledger — the single source of truth
- * for all evidence, claims, challenges, and adjudications in an arena session.
- */
-export class ArenaLedger {
-    ledger;
-    index;
-    constructor() {
-        this.ledger = {
-            dossiers: [],
-            evidencePackets: [],
-            toolTraces: [],
-            claims: [],
-            challenges: [],
-            requestedChecks: [],
-            adjudications: [],
-        };
-        this.index = {
-            claimsById: new Map(),
-            packetsById: new Map(),
-            requestsById: new Map(),
-        };
-    }
-    // ─── Append operations ──────────────────────────────────────
-    /** Check if ledger is approaching memory limits and log warnings */
-    checkGrowth() {
-        const claims = this.ledger.claims.length;
-        const packets = this.ledger.evidencePackets.length;
-        const challenges = this.ledger.challenges.length;
-        if (claims === WARN_CLAIMS || packets === WARN_PACKETS || challenges === WARN_CHALLENGES) {
-            logger.warn("arena.ledger_growth", { claims, packets, challenges, toolTraces: this.ledger.toolTraces.length });
-        }
-    }
-    appendDossier(dossier) {
-        this.ledger.dossiers.push(dossier);
-        for (const packet of dossier.evidencePackets) {
-            this.appendEvidencePacket(packet);
-        }
-        for (const trace of dossier.toolTrace) {
-            this.ledger.toolTraces.push(trace);
-        }
-    }
-    appendEvidencePacket(packet) {
-        // Deduplicate by packetId — reuse existing if same ID
-        if (!this.index.packetsById.has(packet.packetId)) {
-            this.ledger.evidencePackets.push(packet);
-            this.index.packetsById.set(packet.packetId, packet);
-        }
-    }
-    appendClaim(claim) {
-        this.ledger.claims.push(claim);
-        this.index.claimsById.set(claim.claimId, claim);
-        this.checkGrowth();
-    }
-    appendChallenge(challenge) {
-        this.ledger.challenges.push(challenge);
-        // Also add to the claim's challenges array. If the claimId doesn't resolve
-        // the challenge still lives in ledger.challenges but is invisible to any
-        // code reading claim.challenges directly — surface that inconsistency.
-        const claim = this.index.claimsById.get(challenge.claimId);
-        if (claim) {
-            claim.challenges.push(challenge);
-        }
-        else {
-            logger.warn("arena.challenge_for_unknown_claim", { claimId: challenge.claimId });
-        }
-        this.checkGrowth();
-        // Register any requested checks
-        if (challenge.requestedChecks) {
-            for (const check of challenge.requestedChecks) {
-                this.appendRequestedCheck(check);
-            }
-        }
-    }
-    appendRequestedCheck(check) {
-        if (!this.index.requestsById.has(check.requestId)) {
-            this.ledger.requestedChecks.push(check);
-            this.index.requestsById.set(check.requestId, check);
-        }
-    }
-    appendAdjudication(adjudication) {
-        this.ledger.adjudications.push(adjudication);
-        // Also attach to the claim
-        const claim = this.index.claimsById.get(adjudication.claimId);
-        if (claim) {
-            claim.adjudication = adjudication;
-        }
-        else {
-            logger.warn("arena.adjudication_for_unknown_claim", { claimId: adjudication.claimId });
-        }
-    }
-    // ─── Query operations ───────────────────────────────────────
-    /**
-     * Return a read-only reference to the full ledger.
-     *
-     * Note: `Readonly<>` is shallow — inner arrays are still mutable at the
-     * type level. Callers MUST NOT mutate the returned object; use the
-     * append* methods instead. A deep-freeze or structural clone can be
-     * added later if external consumers need a truly immutable snapshot.
-     */
-    getSnapshot() {
-        return this.ledger;
-    }
-    getClaimById(claimId) {
-        return this.index.claimsById.get(claimId);
-    }
-    getPacketById(packetId) {
-        return this.index.packetsById.get(packetId);
-    }
-    getAllClaims() {
-        return this.ledger.claims;
-    }
-    getClaimsByStatus(...statuses) {
-        const set = new Set(statuses);
-        return this.ledger.claims.filter((c) => set.has(c.status));
-    }
-    getClaimsByOwner(owner) {
-        return this.ledger.claims.filter((c) => c.owner === owner);
-    }
-    getChallengesForClaim(claimId) {
-        return this.ledger.challenges.filter((c) => c.claimId === claimId);
-    }
-    getPendingChecks() {
-        return this.ledger.requestedChecks;
-    }
-    getPendingChecksForClaim(claimId) {
-        return this.ledger.requestedChecks.filter((c) => c.claimId === claimId);
-    }
-    getPacketsForClaim(claimId) {
-        const claim = this.index.claimsById.get(claimId);
-        if (!claim)
-            return [];
-        return claim.evidencePacketIds
-            .map((id) => this.index.packetsById.get(id))
-            .filter((p) => p !== undefined);
-    }
-    getDossiers() {
-        return this.ledger.dossiers;
-    }
-    getDossierByParticipant(participant) {
-        // Return the latest dossier for this participant (supports multi-round)
-        const dossiers = this.ledger.dossiers.filter((d) => d.participant === participant);
-        return dossiers[dossiers.length - 1];
-    }
-}

package/dist/arena/lenses/architecture.d.ts

@@ -1,5 +0,0 @@
-/**
- * Architecture lens — system boundaries, modularity, evolution path.
- */
-import type { ArenaLens } from "../types.js";
-export declare const architectureLens: ArenaLens;

package/dist/arena/lenses/architecture.js

@@ -1,22 +0,0 @@
-/**
- * Architecture lens — system boundaries, modularity, evolution path.
- */
-export const architectureLens = {
-    name: "architecture",
-    label: "Architecture",
-    participantRole: "a system architect focused on boundaries, modularity, and evolution paths",
-    reviewerRole: "an architecture reviewer evaluating structural decisions and trade-offs",
-    moderatorRole: "a chief architect synthesizing architectural perspectives into design guidance",
-    summaryLabel: "Architecture Assessment",
-    criteria: [
-        "Module boundaries and responsibility separation",
-        "Coupling and cohesion",
-        "Extensibility and evolution path",
-        "Dependency management",
-        "Data flow and state management",
-        "API surface area and abstraction levels",
-        "Migration and backward compatibility strategy",
-        "Operational concerns (monitoring, debugging, deployment)",
-    ],
-    preferredFindingKinds: ["improvement", "risk", "question", "strength"],
-};

package/dist/arena/lenses/engineering.d.ts

@@ -1,5 +0,0 @@
-/**
- * Engineering lens — code quality, correctness, performance, maintainability.
- */
-import type { ArenaLens } from "../types.js";
-export declare const engineeringLens: ArenaLens;

package/dist/arena/lenses/engineering.js

@@ -1,22 +0,0 @@
-/**
- * Engineering lens — code quality, correctness, performance, maintainability.
- */
-export const engineeringLens = {
-    name: "engineering",
-    label: "Engineering",
-    participantRole: "a software engineer focused on code quality, correctness, and maintainability",
-    reviewerRole: "an engineering peer reviewer evaluating technical rigor and code health",
-    moderatorRole: "a tech lead synthesizing engineering perspectives into actionable conclusions",
-    summaryLabel: "Engineering Assessment",
-    criteria: [
-        "Code correctness and edge case handling",
-        "Error handling and resilience",
-        "Performance and scalability implications",
-        "API design and interface clarity",
-        "Test coverage and testability",
-        "Maintainability and readability",
-        "Security considerations",
-        "Backward compatibility",
-    ],
-    preferredFindingKinds: ["risk", "improvement", "strength", "question"],
-};

package/dist/arena/lenses/general.d.ts

@@ -1,5 +0,0 @@
-/**
- * General lens — broad analysis without a specific domain focus.
- */
-import type { ArenaLens } from "../types.js";
-export declare const generalLens: ArenaLens;

package/dist/arena/lenses/general.js

@@ -1,20 +0,0 @@
-/**
- * General lens — broad analysis without a specific domain focus.
- */
-export const generalLens = {
-    name: "general",
-    label: "General",
-    participantRole: "an analyst providing a broad, balanced perspective",
-    reviewerRole: "a peer reviewer evaluating clarity, logic, and completeness",
-    moderatorRole: "a neutral moderator synthesizing diverse perspectives into balanced conclusions",
-    summaryLabel: "General Assessment",
-    criteria: [
-        "Logical coherence and consistency",
-        "Completeness of analysis",
-        "Trade-off identification",
-        "Assumption clarity",
-        "Evidence quality",
-        "Actionability of recommendations",
-    ],
-    preferredFindingKinds: ["strength", "risk", "question", "improvement"],
-};

package/dist/arena/lenses/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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/arena/lenses/index.js

@@ -1,47 +0,0 @@
-/**
- * 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/arena/lenses/product.d.ts

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

package/dist/arena/lenses/product.js

@@ -1,22 +0,0 @@
-/**
- * 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/arena/model-presets.d.ts

@@ -1,23 +0,0 @@
-/**
- * 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/arena/model-presets.js

@@ -1,44 +0,0 @@
-/**
- * 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 "../onboarding.js";
-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/arena/phases/adjudication.d.ts

@@ -1,25 +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 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 {};