@cjhyy/code-shell-arena 0.8.0

package/dist/context/context-tools.js

@@ -0,0 +1,272 @@
+/**
+ * Context tools — read-only tools that arena participants can use
+ * to fetch additional source context during research.
+ *
+ * Security: All shell commands use execFileSync with argument arrays
+ * to prevent command injection. File paths are validated against the
+ * repository boundary to prevent path traversal.
+ */
+import { readFileSync, existsSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { resolve, join, dirname, basename } from "node:path";
+import { isWithinRoot } from "./within-root.js";
+export const MAX_TOOL_RESULT = 15_000; // chars per tool call
+// 5 was too generous for thinking-mode models — they'd spend the
+// entire budget on read_file with textLen=0, then need an
+// expensive force_conclude round to actually emit findings (logs
+// consistently showed 5/5 rounds + 70-150s force_conclude). Capping
+// at 3 makes the participant commit to a conclusion much sooner.
+export const MAX_TOOL_ROUNDS = 3;
+/** Repository root boundary — all file access is restricted to this directory */
+const REPO_ROOT = resolve(".");
+export const CONTEXT_TOOLS = [
+    {
+        name: "read_file",
+        description: "Read a file from the repository. Use this when you need to see the full source of a file " +
+            "referenced in the context, or to check surrounding code (callers, type definitions, etc.).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Relative file path from repo root" },
+                offset: { type: "number", description: "Start line (1-based, optional)" },
+                limit: { type: "number", description: "Max lines to read (optional, default 200)" },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "grep_code",
+        description: "Search for a pattern across the codebase. Use this to find callers, references, " +
+            "type definitions, or usages of symbols.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "Regex pattern to search for" },
+                glob: { type: "string", description: "File glob filter, e.g. '*.ts' (optional)" },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        name: "list_files",
+        description: "List files in a directory. Use this to understand project structure around relevant files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Directory path relative to repo root (default: '.')" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "git_show",
+        description: "Show a git object (commit, file at a ref, etc.). Use for inspecting specific commits " +
+            "or viewing a file at a different branch/commit.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ref: { type: "string", description: "Git ref, e.g. 'HEAD~3', 'main:src/foo.ts', commit hash" },
+            },
+            required: ["ref"],
+        },
+    },
+    {
+        name: "git_blame",
+        description: "Show git blame for a file. Use to understand who changed what and when.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "File path" },
+                lines: { type: "string", description: "Line range, e.g. '10,20' (optional)" },
+            },
+            required: ["path"],
+        },
+    },
+];
+/**
+ * Execute a context tool call and return the result string.
+ */
+export function executeContextTool(tc) {
+    try {
+        switch (tc.toolName) {
+            case "read_file":
+                return executeReadFile(tc.args);
+            case "grep_code":
+                return executeGrepCode(tc.args);
+            case "list_files":
+                return executeListFiles(tc.args);
+            case "git_show":
+                return executeGitShow(tc.args);
+            case "git_blame":
+                return executeGitBlame(tc.args);
+            default:
+                return `Unknown tool: ${tc.toolName}`;
+        }
+    }
+    catch (err) {
+        return `Tool error: ${err.message}`;
+    }
+}
+/**
+ * Validate that a file path resolves within the repository root.
+ * Returns the resolved absolute path, or null if outside the boundary.
+ */
+function validatePath(filePath) {
+    const resolved = resolve(filePath);
+    // Realpath both sides so a symlink planted inside the repo that points OUTSIDE
+    // can't pass a lexical containment check (isWithinRoot assumes resolved input
+    // and won't catch a link escape on its own). Matches fs-service's discipline.
+    // Reads are read-only, but a contained-looking symlink would still leak an
+    // out-of-repo file into arena context. Fall back to the lexical check when the
+    // target doesn't exist yet (a read of a missing file fails downstream anyway).
+    let realRoot;
+    try {
+        realRoot = realpathSync(REPO_ROOT);
+    }
+    catch {
+        realRoot = REPO_ROOT;
+    }
+    let realTarget;
+    try {
+        realTarget = realpathSync(resolved);
+    }
+    catch {
+        // Target doesn't exist yet. Compare REAL-vs-REAL by resolving the existing
+        // parent dir's realpath and rejoining the missing leaf — comparing realRoot
+        // (a real path) against a lexical `resolved` would false-reject valid files
+        // whenever REPO_ROOT (or any ancestor) is reached through a symlink.
+        let realParent;
+        try {
+            realParent = realpathSync(dirname(resolved));
+        }
+        catch {
+            // Parent missing too — no realpath available; fall back to lexical-vs-lexical
+            // so both operands share the same (unresolved) mode.
+            return isWithinRoot(resolve(REPO_ROOT), resolved) ? resolved : null;
+        }
+        const candidate = join(realParent, basename(resolved));
+        return isWithinRoot(realRoot, candidate) ? candidate : null;
+    }
+    return isWithinRoot(realRoot, realTarget) ? realTarget : null;
+}
+function executeReadFile(args) {
+    const filePath = args.path;
+    if (!validatePath(filePath))
+        return `Error: path outside repository: ${filePath}`;
+    if (!existsSync(filePath))
+        return `Error: file not found: ${filePath}`;
+    const raw = readFileSync(filePath, "utf-8");
+    const lines = raw.split("\n");
+    const offset = Math.max(0, (args.offset ?? 1) - 1);
+    // Guard `limit` before slicing: a negative limit makes lines.slice count
+    // "from the end" and silently drop the file's tail (reader thinks the file is
+    // shorter). A missing/NaN limit falls back to the default; a non-positive
+    // limit reads nothing.
+    const rawLimit = args.limit;
+    const limit = rawLimit === undefined || !Number.isFinite(rawLimit)
+        ? 200
+        : rawLimit > 0
+            ? Math.floor(rawLimit)
+            : 0;
+    const slice = lines.slice(offset, offset + limit);
+    const numbered = slice.map((l, i) => `${offset + i + 1}\t${l}`).join("\n");
+    return truncateResult(numbered);
+}
+function executeGrepCode(args) {
+    const pattern = args.pattern;
+    const glob = args.glob;
+    const grepArgs = ["-rn", "-E", "--"];
+    if (glob) {
+        grepArgs.splice(1, 0, `--include=${glob}`);
+    }
+    grepArgs.push(pattern, ".");
+    const result = execFileSafe("grep", grepArgs, 80);
+    return result || "No matches found.";
+}
+function executeListFiles(args) {
+    const dir = args.path || ".";
+    if (!validatePath(dir))
+        return `Error: path outside repository: ${dir}`;
+    try {
+        const entries = readdirSync(dir);
+        const lines = [];
+        for (const entry of entries.slice(0, 50)) {
+            const fullPath = join(dir, entry);
+            try {
+                const st = statSync(fullPath);
+                const type = st.isDirectory() ? "d" : "-";
+                const size = st.isDirectory() ? "" : ` ${st.size}`;
+                lines.push(`${type} ${entry}${size}`);
+            }
+            catch {
+                lines.push(`? ${entry}`);
+            }
+        }
+        return lines.join("\n") || `Empty directory: ${dir}`;
+    }
+    catch {
+        return `Directory not found: ${dir}`;
+    }
+}
+function executeGitShow(args) {
+    const ref = sanitizeGitRef(args.ref);
+    if (!ref)
+        return "Error: invalid git ref";
+    const result = execFileSafe("git", ["show", "--", ref], 200);
+    return truncateResult(result || `Could not resolve: ${ref}`);
+}
+function executeGitBlame(args) {
+    const filePath = args.path;
+    if (!validatePath(filePath))
+        return `Error: path outside repository: ${filePath}`;
+    const lines = args.lines;
+    const gitArgs = ["blame"];
+    if (lines && /^\d+,\d+$/.test(lines)) {
+        gitArgs.push(`-L`, lines);
+    }
+    gitArgs.push("--", filePath);
+    const result = execFileSafe("git", gitArgs, 50);
+    return result || `Could not blame: ${filePath}`;
+}
+/**
+ * Sanitize a git ref string from LLM output.
+ * Only allows safe git ref characters.
+ */
+function sanitizeGitRef(ref) {
+    if (!ref || ref.length > 200)
+        return null;
+    // Only allow alphanumeric, /, -, _, ~, ^, ., :
+    const cleaned = ref.replace(/[^a-zA-Z0-9/_\-~^.:]/g, "");
+    // Block shell metacharacters and path traversal attempts
+    if (/\.\.\/|;\s|&&|\|\||`|\$\(/.test(cleaned))
+        return null;
+    return cleaned || null;
+}
+/**
+ * Execute a command safely using execFileSync (no shell interpretation).
+ * Optionally limits output to maxLines.
+ */
+function execFileSafe(cmd, args, maxLines) {
+    try {
+        const raw = execFileSync(cmd, args, {
+            encoding: "utf-8",
+            maxBuffer: 512 * 1024,
+            timeout: 10_000,
+        }).trim();
+        if (maxLines) {
+            const lines = raw.split("\n");
+            if (lines.length > maxLines) {
+                return lines.slice(0, maxLines).join("\n") + `\n... (${lines.length - maxLines} more lines)`;
+            }
+        }
+        return raw;
+    }
+    catch {
+        return "";
+    }
+}
+function truncateResult(text) {
+    if (text.length <= MAX_TOOL_RESULT)
+        return text;
+    return text.slice(0, MAX_TOOL_RESULT) + "\n... (truncated)";
+}

package/dist/context/within-root.d.ts

@@ -0,0 +1,7 @@
+/**
+ * True when `target` is the root itself or a descendant of it. Uses the
+ * platform separator (the old check hardcoded "/", which broke on Windows)
+ * and avoids the sibling-prefix trap (/repo vs /repo-evil). Both inputs are
+ * assumed already resolved to absolute paths.
+ */
+export declare function isWithinRoot(root: string, target: string): boolean;

package/dist/context/within-root.js

@@ -0,0 +1,15 @@
+import * as path from "node:path";
+/**
+ * True when `target` is the root itself or a descendant of it. Uses the
+ * platform separator (the old check hardcoded "/", which broke on Windows)
+ * and avoids the sibling-prefix trap (/repo vs /repo-evil). Both inputs are
+ * assumed already resolved to absolute paths.
+ */
+export function isWithinRoot(root, target) {
+    if (target === root)
+        return true;
+    const rel = path.relative(root, target);
+    // Outside the root iff the relative path climbs out ("..") or is absolute
+    // (different drive on Windows).
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}

package/dist/detect-mode.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Arena mode auto-detection — infer review/discussion/planning from topic text.
+ *
+ * Heuristic-based: uses keyword matching with weighted scoring.
+ * Falls back to "review" (safest default) when confidence is low.
+ */
+import type { ArenaMode } from "./types.js";
+/** Result of heuristic mode detection */
+export interface ArenaModeDetection {
+    mode: ArenaMode;
+    confidence: "high" | "low";
+    reason: string;
+}
+/**
+ * Auto-detect arena mode from the topic string.
+ *
+ * Returns the detected mode, confidence level, and a human-readable reason.
+ * When confidence is low, falls back to "review" (the safest default).
+ */
+export declare function detectArenaMode(topic: string): ArenaModeDetection;

package/dist/detect-mode.js

@@ -0,0 +1,78 @@
+/**
+ * Arena mode auto-detection — infer review/discussion/planning from topic text.
+ *
+ * Heuristic-based: uses keyword matching with weighted scoring.
+ * Falls back to "review" (safest default) when confidence is low.
+ */
+const MODE_SIGNALS = {
+    review: [
+        { patterns: [/\breview\b/i, /\baudit\b/i, /\binspect\b/i, /\bcheck\b/i], weight: 2 },
+        { patterns: [/\bcode\s*quality\b/i, /\bbug\b/i, /\bvulnerab/i, /\bsecur/i] },
+        { patterns: [/\bpr\b/i, /\bpull\s*request\b/i, /\bdiff\b/i, /\bchanges?\b/i] },
+        { patterns: [/\brefactor/i, /\bclean\s*up\b/i, /\bimprove\b/i] },
+    ],
+    discussion: [
+        { patterns: [/\bdiscuss\b/i, /\bdebate\b/i, /\bcompare\b/i], weight: 2 },
+        { patterns: [/\bpros?\s*(and|&|\/)\s*cons?\b/i, /\btrade\s*-?\s*offs?\b/i] },
+        { patterns: [/\bshould\s+we\b/i, /\bwhich\s+(is|approach|way)\b/i, /\bvs\.?\b/i] },
+        { patterns: [/\bopinion\b/i, /\bthoughts?\b/i, /\badvice\b/i] },
+    ],
+    planning: [
+        { patterns: [/\bplan\b/i, /\bplanning\b/i, /\broadmap\b/i, /\bstrategy\b/i], weight: 2 },
+        { patterns: [/\barchitect/i, /\bdesign\b/i, /\bproposal\b/i] },
+        { patterns: [/\bimplement(ation)?\s+(plan|strategy|approach)\b/i], weight: 2 },
+        { patterns: [/\bphase\b/i, /\bmilestone\b/i, /\btimeline\b/i, /\bprioritiz/i] },
+        { patterns: [/\bbuild\b/i, /\bcreate\b/i, /\bsetup\b/i, /\bbootstrap\b/i] },
+    ],
+};
+/** Confidence threshold: below this → low confidence */
+const HIGH_CONFIDENCE_THRESHOLD = 3;
+/** Minimum lead over runner-up to be "high" confidence */
+const MIN_LEAD = 2;
+// ─── Detection ──────────────────────────────────────────────────
+/**
+ * Auto-detect arena mode from the topic string.
+ *
+ * Returns the detected mode, confidence level, and a human-readable reason.
+ * When confidence is low, falls back to "review" (the safest default).
+ */
+export function detectArenaMode(topic) {
+    const scores = { review: 0, discussion: 0, planning: 0 };
+    for (const [mode, signals] of Object.entries(MODE_SIGNALS)) {
+        for (const signal of signals) {
+            const weight = signal.weight ?? 1;
+            for (const pattern of signal.patterns) {
+                if (pattern.test(topic)) {
+                    scores[mode] += weight;
+                }
+            }
+        }
+    }
+    // Sort modes by score descending
+    const ranked = Object.entries(scores)
+        .sort((a, b) => b[1] - a[1]);
+    const [bestMode, bestScore] = ranked[0];
+    const [, runnerUpScore] = ranked[1];
+    const lead = bestScore - runnerUpScore;
+    // Determine confidence
+    if (bestScore >= HIGH_CONFIDENCE_THRESHOLD && lead >= MIN_LEAD) {
+        return {
+            mode: bestMode,
+            confidence: "high",
+            reason: `Topic strongly matches "${bestMode}" (score: ${bestScore}, lead: +${lead})`,
+        };
+    }
+    if (bestScore > 0 && lead > 0) {
+        return {
+            mode: bestMode,
+            confidence: "low",
+            reason: `Topic weakly matches "${bestMode}" (score: ${bestScore}, lead: +${lead})`,
+        };
+    }
+    // No signal at all → default to review
+    return {
+        mode: "review",
+        confidence: "low",
+        reason: "No strong mode signal detected, defaulting to review",
+    };
+}

package/dist/digest-builder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DigestBuilder — constructs RoundResearchDigest from the shared ledger.
+ *
+ * The digest is a filtered view injected into prompts to avoid
+ * token explosion from the full ledger. Program-built, not model-built.
+ */
+import type { ArenaLedger } from "./ledger.js";
+import type { RoundResearchDigest } from "./types.js";
+interface DigestOptions {
+    /** Current round number */
+    round: number;
+    /** Claim IDs relevant to this round (e.g. contested claims in debate) */
+    relevantClaimIds: string[];
+}
+/**
+ * Build a digest from the shared ledger for a specific round.
+ * Only includes data relevant to the specified claims.
+ */
+export declare function buildDigest(ledger: ArenaLedger, options: DigestOptions): RoundResearchDigest;
+/**
+ * Format a digest into a text block suitable for prompt injection.
+ * All LLM-originated text is sanitized before inclusion.
+ */
+export declare function formatDigest(digest: RoundResearchDigest): string;
+export {};

package/dist/digest-builder.js

@@ -0,0 +1,120 @@
+/**
+ * DigestBuilder — constructs RoundResearchDigest from the shared ledger.
+ *
+ * The digest is a filtered view injected into prompts to avoid
+ * token explosion from the full ledger. Program-built, not model-built.
+ */
+/**
+ * Build a digest from the shared ledger for a specific round.
+ * Only includes data relevant to the specified claims.
+ */
+export function buildDigest(ledger, options) {
+    const { round, relevantClaimIds } = options;
+    const claimIdSet = new Set(relevantClaimIds);
+    const snapshot = ledger.getSnapshot();
+    // Collect evidence packets referenced by relevant claims
+    const packetIds = new Set();
+    for (const claimId of relevantClaimIds) {
+        const claim = ledger.getClaimById(claimId);
+        if (claim) {
+            for (const pid of claim.evidencePacketIds) {
+                packetIds.add(pid);
+            }
+        }
+    }
+    const evidencePackets = [];
+    for (const pid of packetIds) {
+        const packet = ledger.getPacketById(pid);
+        if (packet)
+            evidencePackets.push(packet);
+    }
+    // Tool trace summary — built directly from dossiers to preserve participant ownership
+    const toolTraceSummary = [];
+    for (const dossier of snapshot.dossiers) {
+        for (const trace of dossier.toolTrace) {
+            if (trace.keptAsEvidence) {
+                toolTraceSummary.push({
+                    participant: dossier.participant,
+                    toolName: trace.toolName,
+                    ref: trace.resultRef,
+                });
+            }
+        }
+    }
+    // Recent challenges for relevant claims
+    const recentChallenges = snapshot.challenges
+        .filter((c) => claimIdSet.has(c.claimId));
+    // Pending requested checks for relevant claims
+    const requestedChecks = snapshot.requestedChecks
+        .filter((c) => claimIdSet.has(c.claimId));
+    // Prior adjudications for relevant claims
+    const priorAdjudications = snapshot.adjudications
+        .filter((a) => claimIdSet.has(a.claimId));
+    return {
+        round,
+        relevantClaimIds,
+        evidencePackets,
+        toolTraceSummary,
+        recentChallenges,
+        requestedChecks,
+        priorAdjudications,
+    };
+}
+/**
+ * Sanitize text from LLM output before re-injecting into a prompt.
+ * Strips patterns that could be interpreted as prompt-level instructions.
+ */
+function sanitize(text) {
+    if (!text)
+        return "";
+    return text
+        // Strip fake system/assistant role tags
+        .replace(/<\/?(?:system|assistant|user|system-reminder)[^>]*>/gi, "")
+        // Strip instruction-like prefixes (case-insensitive)
+        .replace(/^(?:IGNORE|DISREGARD|FORGET|OVERRIDE|SYSTEM|INSTRUCTION)[:\s].*/gim, "")
+        // Collapse excessive whitespace
+        .replace(/\n{3,}/g, "\n\n")
+        // Limit length per field
+        .slice(0, 2000);
+}
+/**
+ * Format a digest into a text block suitable for prompt injection.
+ * All LLM-originated text is sanitized before inclusion.
+ */
+export function formatDigest(digest) {
+    const sections = [];
+    sections.push(`## Round ${digest.round} Research Digest`);
+    sections.push(`Claims under consideration: ${digest.relevantClaimIds.join(", ")}`);
+    if (digest.evidencePackets.length > 0) {
+        sections.push("\n### Evidence");
+        for (const packet of digest.evidencePackets) {
+            sections.push(`- [${packet.packetId}] ${sanitize(packet.title)} (${packet.source})`);
+            sections.push(`  ${sanitize(packet.summary)}`);
+            for (const excerpt of packet.excerpts.slice(0, 3)) {
+                sections.push(`  > ${excerpt.ref}: ${sanitize(excerpt.snippet)}`);
+                if (excerpt.note)
+                    sections.push(`    Note: ${sanitize(excerpt.note)}`);
+            }
+        }
+    }
+    if (digest.recentChallenges.length > 0) {
+        sections.push("\n### Challenges");
+        for (const c of digest.recentChallenges) {
+            sections.push(`- [${c.reviewer}] on ${c.claimId}: ${c.verdict} — ${sanitize(c.reason)}`);
+        }
+    }
+    if (digest.requestedChecks.length > 0) {
+        sections.push("\n### Requested Checks");
+        for (const check of digest.requestedChecks) {
+            const pri = check.priority ? ` (${check.priority})` : "";
+            sections.push(`- [${check.requestId}]${pri}: ${sanitize(check.description)}`);
+        }
+    }
+    if (digest.priorAdjudications.length > 0) {
+        sections.push("\n### Prior Adjudications");
+        for (const adj of digest.priorAdjudications) {
+            sections.push(`- ${adj.claimId}: ${adj.outcome} — ${sanitize(adj.rationale)}`);
+        }
+    }
+    return sections.join("\n");
+}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Arena compatibility root.
+ *
+ * Product hosts should prefer /runtime. The remaining exports expose advanced
+ * algorithms and Iterate mode for existing SDK consumers.
+ */
+export * from "./index.runtime.js";
+export { getStrategy, getStrategyForPlan, ReviewStrategy, DiscussionStrategy, PlanningStrategy, } from "./strategies/index.js";
+export { planArena } from "./planner.js";
+export { collectEvidence } from "./providers/index.js";
+export { selectTools, hasTools } from "./tools/selector.js";
+export { getLens, resolveLenses, buildLensPrompt, LENS_NAMES } from "./lenses/index.js";
+export { runParticipantResearch, runParticipantResearchWithDossiers, } from "./phases/participant-research.js";
+export type { ResearchResult } from "./phases/participant-research.js";
+export { runCrossReview, runVerificationReview } from "./phases/cross-review.js";
+export { runDebateRounds } from "./phases/debate-rounds.js";
+export { runAdjudication } from "./phases/adjudication.js";
+export { buildConsensus } from "./phases/build-consensus.js";
+export { registerClaims, selectClaimsForReview } from "./phases/claim-registry.js";
+export { ArenaLedger } from "./ledger.js";
+export { buildDigest, formatDigest } from "./digest-builder.js";
+export { transitionClaim, resolveClaimStatus, markUnderReview, applyReviewResult, markUnresolved, isTerminal, validTransitions, } from "./transitions.js";
+export { IterativeArena } from "./iterate/index.js";
+export { defaultConvergence as defaultIterateConvergence, diffRatio as iterateDiffRatio, codeFormat as iterateCodeFormat, documentFormat as iterateDocumentFormat, getFormat as getIterateFormat, } from "./iterate/index.js";
+export type { AuthorRotation, CheckpointAction, CheckpointContext, CheckpointFn, ConvergenceSignal, Critique, CritiqueCategory, CritiqueEvidence, CritiqueSeverity, Draft, DraftCandidate, IterateConfig, IterateFormat, IterateProgressEvent, IterateResult, IterateSubject, Round, StoppedReason, FormatPack as IterateFormatPack, } from "./iterate/index.js";

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * Arena compatibility root.
+ *
+ * Product hosts should prefer /runtime. The remaining exports expose advanced
+ * algorithms and Iterate mode for existing SDK consumers.
+ */
+export * from "./index.runtime.js";
+export { getStrategy, getStrategyForPlan, ReviewStrategy, DiscussionStrategy, PlanningStrategy, } from "./strategies/index.js";
+export { planArena } from "./planner.js";
+export { collectEvidence } from "./providers/index.js";
+export { selectTools, hasTools } from "./tools/selector.js";
+export { getLens, resolveLenses, buildLensPrompt, LENS_NAMES } from "./lenses/index.js";
+export { runParticipantResearch, runParticipantResearchWithDossiers, } from "./phases/participant-research.js";
+export { runCrossReview, runVerificationReview } from "./phases/cross-review.js";
+export { runDebateRounds } from "./phases/debate-rounds.js";
+export { runAdjudication } from "./phases/adjudication.js";
+export { buildConsensus } from "./phases/build-consensus.js";
+export { registerClaims, selectClaimsForReview } from "./phases/claim-registry.js";
+export { ArenaLedger } from "./ledger.js";
+export { buildDigest, formatDigest } from "./digest-builder.js";
+export { transitionClaim, resolveClaimStatus, markUnderReview, applyReviewResult, markUnresolved, isTerminal, validTransitions, } from "./transitions.js";
+export { IterativeArena } from "./iterate/index.js";
+export { defaultConvergence as defaultIterateConvergence, diffRatio as iterateDiffRatio, codeFormat as iterateCodeFormat, documentFormat as iterateDocumentFormat, getFormat as getIterateFormat, } from "./iterate/index.js";

package/dist/index.runtime.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Stable host runtime for Arena.
+ *
+ * This entry intentionally excludes phase/strategy internals and Iterate mode.
+ */
+export { Arena } from "./arena.js";
+export { arenaTool, arenaToolDef, ArenaCapabilitySettingsSchema, createArenaCapability, getArenaStatus, saveArenaSettingsByKeys, type ArenaStatus, } from "./capability.js";
+export { MODEL_PRESETS, getMaxOutputTokens } from "./model-presets.js";
+export type { ModelPreset } from "./model-presets.js";
+export { formatArenaResult, printArenaResult, renderProgress, createProgressRenderer, type OutputSink, } from "./render/terminal.js";
+export { formatArenaResultForSession } from "./render/session.js";
+export type { ArenaConfig, ArenaResultV2, ArenaStrategy, ArenaStrategyV2, ClaimStatusSummary, ArenaParticipant, ArenaBaseContext, ArenaFinding, FindingReview, ParticipantReport, ArenaConsensus, ArenaConsensusItem, ArenaRoadmapPhase, ArenaProgressEvent, ArenaMode, FindingKind, PeerVerdict, ArenaPlan, ArenaLens, ArenaLensName, ArenaLensRef, ArenaSourceKind, ArenaSourceSpec, ArenaSubject, ArenaOutputShape, ArenaArtifact, ArenaToolPack, ArenaContextProvider, ArenaQuickFact, ToolTrace, EvidencePacket, FindingEvidenceLink, ResearchDossier, ClaimStatus, ClaimRecord, ClaimChallenge, ClaimAdjudication, RequestedCheck, DebateRound, DebateTurn, TargetedCheckTask, SharedResearchLedger, RoundResearchDigest, ArenaExecutionLimits, } from "./types.js";
+export { isStrategyV2 } from "./types.js";

package/dist/index.runtime.js

@@ -0,0 +1,11 @@
+/**
+ * Stable host runtime for Arena.
+ *
+ * This entry intentionally excludes phase/strategy internals and Iterate mode.
+ */
+export { Arena } from "./arena.js";
+export { arenaTool, arenaToolDef, ArenaCapabilitySettingsSchema, createArenaCapability, getArenaStatus, saveArenaSettingsByKeys, } from "./capability.js";
+export { MODEL_PRESETS, getMaxOutputTokens } from "./model-presets.js";
+export { formatArenaResult, printArenaResult, renderProgress, createProgressRenderer, } from "./render/terminal.js";
+export { formatArenaResultForSession } from "./render/session.js";
+export { isStrategyV2 } from "./types.js";

package/dist/iterate/convergence.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Convergence detection — when has the draft stabilized enough to stop?
+ */
+import type { ConvergenceSignal, Critique, Draft } from "./types.js";
+/**
+ * Cheap O(n) approximation of "how different is new vs old".
+ * Returns 0..1 where 0 = identical, 1 = completely different.
+ *
+ * Uses character-trigram Jaccard distance — fast, good enough for "is the
+ * author actually changing anything substantial?".
+ */
+export declare function diffRatio(a: string, b: string): number;
+/**
+ * Default convergence rule:
+ *   stop if blockers == 0 AND
+ *     (all critiques are minor/nit/praise OR diff < 5% from last version)
+ *
+ * Round 1 never converges (need at least one revision pass).
+ */
+export declare function defaultConvergence(args: {
+    round: number;
+    critiques: Critique[];
+    draft: Draft;
+    previousDraft?: Draft;
+}): ConvergenceSignal;