@cjhyy/code-shell 0.1.0-alpha.0

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

@@ -0,0 +1,45 @@
+/**
+ * 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 } 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;
+}
+/**
+ * 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;
+}
+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/debate-rounds.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 } 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;
+}
+/**
+ * Run debate rounds for all contested claims.
+ * Returns empty array if no contested claims exist.
+ */
+export declare function runDebateRounds(options: DebateOptions): Promise<DebateRound[]>;
+export {};

package/dist/arena/phases/participant-research.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ParticipantResearch — each participant independently investigates
+ * the shared base context and produces structured findings.
+ *
+ * Phase 3 upgrade: now captures ToolTrace and builds EvidencePackets,
+ * outputting a full ResearchDossier alongside the ParticipantReport.
+ */
+import type { ArenaBaseContext, ArenaParticipant, ArenaStrategy, ParticipantReport, ResearchDossier, ArenaProgressEvent } from "../types.js";
+import type { ToolDefinition } from "../../types.js";
+/** Result of a single participant's research — includes both report and dossier */
+export interface ResearchResult {
+    report: ParticipantReport;
+    dossier: ResearchDossier;
+}
+interface ResearchOptions {
+    participants: ArenaParticipant[];
+    strategy: ArenaStrategy;
+    topic: string;
+    baseContext: ArenaBaseContext;
+    enableContextTools?: boolean;
+    /** Plan-selected tools override. When provided, these are used instead of all CONTEXT_TOOLS. */
+    contextTools?: ToolDefinition[];
+    /** AbortSignal — cancels in-flight LLM calls */
+    signal?: AbortSignal;
+    onProgress?: (event: ArenaProgressEvent) => void;
+}
+/**
+ * Run participant research phase in parallel.
+ * Each participant reads the shared context, optionally requests more,
+ * then produces structured findings with evidence trails.
+ */
+export declare function runParticipantResearch(options: ResearchOptions): Promise<ParticipantReport[]>;
+/**
+ * Run participant research phase with full dossier output.
+ * Returns both reports (backward compat) and dossiers (evidence trail).
+ */
+export declare function runParticipantResearchWithDossiers(options: ResearchOptions): Promise<ResearchResult[]>;
+export {};

package/dist/arena/phases/planning-detail-expansion.d.ts

@@ -0,0 +1,38 @@
+/**
+ * PlanningDetailExpansion — expands high-level roadmap phases into
+ * repo-level implementation plans.
+ *
+ * This phase is planning-mode specific. It takes the roadmap produced
+ * by consensus and, for each phase, calls the LLM to produce concrete
+ * implementation details: target files, code changes, interfaces,
+ * migration steps, validation, effort, and blockers.
+ *
+ * Tool access is available so the LLM can verify file paths and interfaces.
+ */
+import type { ArenaParticipant, ArenaRoadmapPhase, ArenaRoadmapPhaseDetail, ArenaProgressEvent, ArenaExecutionLimits, ArenaStrategyPlanning } from "../types.js";
+import type { ToolDefinition } from "../../types.js";
+import type { ArenaLedger } from "../ledger.js";
+interface DetailExpansionOptions {
+    /** The participant that performs the expansion (typically the concluder) */
+    concluder: ArenaParticipant;
+    strategy: ArenaStrategyPlanning;
+    topic: string;
+    /** Roadmap phases to expand */
+    phases: ArenaRoadmapPhase[];
+    ledger: ArenaLedger;
+    limits: ArenaExecutionLimits;
+    /** Enable read-only context tools for file path verification */
+    enableContextTools?: boolean;
+    /** Plan-selected tools override */
+    contextTools?: ToolDefinition[];
+    signal?: AbortSignal;
+    onProgress?: (event: ArenaProgressEvent) => void;
+}
+/**
+ * Expand each roadmap phase into a repo-level implementation plan.
+ *
+ * Phases are expanded sequentially to avoid token explosion.
+ * The number of phases expanded is capped by limits.maxExpandedPhasesPerRun.
+ */
+export declare function runDetailExpansion(options: DetailExpansionOptions): Promise<ArenaRoadmapPhaseDetail[]>;
+export {};

package/dist/arena/planner.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Planner — the brain of Evidence-Driven Arena.
+ *
+ * Takes a natural language user request and produces a complete ArenaPlan:
+ * - mode (how to collaborate)
+ * - lenses (from what perspectives)
+ * - sources (where to gather evidence)
+ * - subject (what is being analyzed)
+ * - outputShape (how to structure the result)
+ *
+ * Replaces the old IntentResolver + ScopeResolver pipeline with a single
+ * LLM call that outputs a holistic execution plan.
+ */
+import type { LLMConfig } from "../types.js";
+import type { ArenaPlan, ArenaMode } from "./types.js";
+/** Explicit flags the user may pass via CLI or tool args */
+export interface PlannerFlags {
+    mode?: ArenaMode;
+    base?: string;
+    head?: string;
+}
+/**
+ * Run the planner to produce an ArenaPlan from natural language.
+ *
+ * Priority: explicit flags > LLM plan > safe defaults.
+ */
+export declare function planArena(topic: string, llmConfig: LLMConfig, flags?: PlannerFlags, signal?: AbortSignal): Promise<ArenaPlan>;

package/dist/arena/providers/docs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * DocsProvider — collects evidence from documentation files:
+ * markdown, text, PRDs, design docs.
+ */
+import type { ArenaContextProvider } from "../types.js";
+export declare const docsProvider: ArenaContextProvider;

package/dist/arena/providers/git.d.ts

@@ -0,0 +1,8 @@
+/**
+ * GitProvider — collects evidence from git: diffs, commit logs, changed files.
+ *
+ * Security: All git commands use execFileSync with argument arrays
+ * to prevent shell injection. Git refs are sanitized before use.
+ */
+import type { ArenaContextProvider } from "../types.js";
+export declare const gitProvider: ArenaContextProvider;

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

@@ -0,0 +1,16 @@
+/**
+ * Provider registry — evidence collectors for Arena.
+ */
+import type { ArenaPlan, ArenaArtifact, ArenaQuickFact } from "../types.js";
+export { gitProvider } from "./git.js";
+export { repoProvider } from "./repo.js";
+export { docsProvider } from "./docs.js";
+export { noneProvider } from "./none.js";
+/**
+ * Collect all evidence according to the plan's sources.
+ * Returns unified ArenaArtifact[] and quickFacts.
+ */
+export declare function collectEvidence(plan: ArenaPlan, topic: string): {
+    artifacts: ArenaArtifact[];
+    quickFacts: ArenaQuickFact[];
+};

package/dist/arena/providers/none.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NoneProvider — returns no external evidence.
+ * Used for pure topic discussions, brainstorming, or debates
+ * where no external context is needed.
+ */
+import type { ArenaContextProvider } from "../types.js";
+export declare const noneProvider: ArenaContextProvider;

package/dist/arena/providers/repo.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RepoProvider — collects evidence from the code repository:
+ * directory trees, key files, grep results.
+ */
+import type { ArenaContextProvider } from "../types.js";
+export declare const repoProvider: ArenaContextProvider;

package/dist/arena/render/session.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Session renderer — formats ArenaResultV2 into markdown suitable for
+ * displaying as assistant_text and as context for follow-up LLM turns.
+ *
+ * Scene-aware output order:
+ *   1. Subject Summary — factual framing / what changed / current scope
+ *   2. Overall assessment
+ *   3. Roadmap (planning-first when present)
+ *   4. Consensus sections ordered by output emphasis
+ *   5. Next Actions
+ *   6. Per-participant findings (collapsed)
+ */
+import type { ArenaResultV2 } from "../types.js";
+/**
+ * Format an ArenaResultV2 into markdown text.
+ */
+export declare function formatArenaResultForSession(result: ArenaResultV2): string;

package/dist/arena/render/terminal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Terminal renderer — renders ArenaConsensus and ArenaResultV2.
+ *
+ * All render functions return strings instead of printing directly,
+ * so callers can decide where to display (ctx.addStatus vs console.log).
+ *
+ * Output sections:
+ * 1. Summary
+ * 2. Roadmap (surfaced early for planning scenes)
+ * 3. Consensus sections ordered by output emphasis
+ * 4. Next Actions
+ */
+import type { ArenaResultV2, ArenaProgressEvent } from "../types.js";
+/** Output sink — callers provide this to control where text goes. */
+export type OutputSink = (text: string) => void;
+/**
+ * Format the full arena result as a styled string.
+ */
+export declare function formatArenaResult(result: ArenaResultV2): string;
+/**
+ * Print the full arena result directly to stdout.
+ * Used by the CLI `code-shell arena` command (non-REPL).
+ */
+export declare function printArenaResult(result: ArenaResultV2): void;
+/**
+ * Create a progress renderer that sends output to a sink.
+ * For REPL: pass ctx.addStatus. For CLI: pass console.log.
+ */
+export declare function createProgressRenderer(sink: OutputSink): (event: ArenaProgressEvent) => void;
+/**
+ * Legacy: direct console.log progress renderer for CLI mode.
+ */
+export declare function renderProgress(event: ArenaProgressEvent): void;

package/dist/arena/strategies/discussion.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Discussion strategy — open-ended debate with structured findings.
+ *
+ * V2: focuses on trade-offs, competing viewpoints, and evidence-backed arguments.
+ */
+import type { ArenaStrategyV2, ArenaBaseContext, ParticipantReport, FindingReview, ArenaConsensus, FindingKind, ClaimRecord, ClaimChallenge, ClaimAdjudication, ClaimStatusSummary, DebateTurn, DebateRound, RoundResearchDigest } from "../types.js";
+export declare class DiscussionStrategy implements ArenaStrategyV2 {
+    researchSystemPrompt(name: string): string;
+    researchUserPrompt(topic: string, baseContext: ArenaBaseContext): string;
+    parseResearchResponse(participant: string, text: string): ParticipantReport;
+    crossReviewSystemPrompt(reviewerName: string): string;
+    crossReviewUserPrompt(topic: string, myReport: ParticipantReport, otherReports: ParticipantReport[]): string;
+    parseCrossReviewResponse(reviewer: string, text: string): FindingReview[];
+    consensusSystemPrompt(): string;
+    consensusUserPrompt(topic: string, reports: ParticipantReport[], reviews: FindingReview[]): string;
+    parseConsensusResponse(text: string): ArenaConsensus;
+    preferredFindingKinds(): FindingKind[];
+    verificationReviewUserPrompt(topic: string, myReport: ParticipantReport, claimsToReview: ClaimRecord[], digest: RoundResearchDigest): string;
+    parseVerificationReviewResponse(reviewer: string, text: string): ClaimChallenge[];
+    debateTurnUserPrompt(topic: string, claim: ClaimRecord, priorTurns: DebateTurn[], digest: RoundResearchDigest): string;
+    parseDebateTurnResponse(participant: string, text: string): DebateTurn;
+    adjudicationUserPrompt(topic: string, claim: ClaimRecord, debateRounds: DebateRound[], digest: RoundResearchDigest): string;
+    parseAdjudicationResponse(text: string): ClaimAdjudication;
+    claimAwareConsensusUserPrompt(topic: string, reports: ParticipantReport[], reviews: FindingReview[], claimSummary: ClaimStatusSummary): string;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Arena strategies — mode-specific behavior for the arena orchestration loop.
+ */
+export { ReviewStrategy } from "./review.js";
+export { DiscussionStrategy } from "./discussion.js";
+export { PlanningStrategy } from "./planning.js";
+export { withLens } from "./lens-wrapper.js";
+import type { ArenaMode, ArenaStrategy, ArenaPlan } from "../types.js";
+/** Get the default strategy for a given arena mode. */
+export declare function getStrategy(mode: ArenaMode): ArenaStrategy;
+/**
+ * Get a strategy for a plan — mode strategy + lens wrapper.
+ * This is the new evidence-driven entry point.
+ */
+export declare function getStrategyForPlan(plan: ArenaPlan): ArenaStrategy;

package/dist/arena/strategies/language-wrapper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Language-aware strategy wrapper.
+ *
+ * Detects the language of the user's query and injects a language instruction
+ * into all strategy system prompts so the arena output matches the query language.
+ */
+import type { ArenaStrategy } from "../types.js";
+/**
+ * Detect whether the topic is primarily non-English.
+ * Returns a language instruction string, or empty if English.
+ */
+export declare function detectLanguageInstruction(topic: string): string;
+/**
+ * Wrap a strategy to inject language instructions into all system prompts.
+ * If the topic is English, returns the original strategy unchanged.
+ */
+export declare function withLanguage(strategy: ArenaStrategy, topic: string): ArenaStrategy;

package/dist/arena/strategies/lens-wrapper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Lens-aware strategy wrapper.
+ *
+ * Composes a mode strategy with lens-specific prompts:
+ *   systemPrompt = modeStrategy.systemPrompt() + lensPrompt + toolGuidance
+ *
+ * This achieves the separation described in the architecture doc:
+ * - Strategy (mode) → how to collaborate
+ * - Lens → from what perspective
+ */
+import type { ArenaStrategy, ArenaPlan } from "../types.js";
+/**
+ * Wrap a strategy to inject lens-specific role and criteria prompts.
+ * If no plan is provided, returns the original strategy unchanged.
+ */
+export declare function withLens(strategy: ArenaStrategy, plan: ArenaPlan): ArenaStrategy;

package/dist/arena/strategies/planning.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Planning strategy — collaborative roadmap building with structured findings.
+ *
+ * V2: focuses on implementation phases, dependencies, risks, and open questions.
+ */
+import type { ArenaStrategyPlanning, ArenaBaseContext, ParticipantReport, FindingReview, ArenaConsensus, FindingKind, ClaimRecord, ClaimChallenge, ClaimAdjudication, ClaimStatusSummary, DebateTurn, DebateRound, RoundResearchDigest, ArenaRoadmapPhase, ArenaRoadmapPhaseDetail } from "../types.js";
+export declare class PlanningStrategy implements ArenaStrategyPlanning {
+    researchSystemPrompt(name: string): string;
+    researchUserPrompt(topic: string, baseContext: ArenaBaseContext): string;
+    parseResearchResponse(participant: string, text: string): ParticipantReport;
+    crossReviewSystemPrompt(reviewerName: string): string;
+    crossReviewUserPrompt(topic: string, myReport: ParticipantReport, otherReports: ParticipantReport[]): string;
+    parseCrossReviewResponse(reviewer: string, text: string): FindingReview[];
+    consensusSystemPrompt(): string;
+    consensusUserPrompt(topic: string, reports: ParticipantReport[], reviews: FindingReview[]): string;
+    parseConsensusResponse(text: string): ArenaConsensus;
+    preferredFindingKinds(): FindingKind[];
+    verificationReviewUserPrompt(topic: string, myReport: ParticipantReport, claimsToReview: ClaimRecord[], digest: RoundResearchDigest): string;
+    parseVerificationReviewResponse(reviewer: string, text: string): ClaimChallenge[];
+    debateTurnUserPrompt(topic: string, claim: ClaimRecord, priorTurns: DebateTurn[], digest: RoundResearchDigest): string;
+    parseDebateTurnResponse(participant: string, text: string): DebateTurn;
+    adjudicationUserPrompt(topic: string, claim: ClaimRecord, debateRounds: DebateRound[], digest: RoundResearchDigest): string;
+    parseAdjudicationResponse(text: string): ClaimAdjudication;
+    mergeReviewUserPrompt(topic: string, myReport: ParticipantReport, claimsToReview: ClaimRecord[], digest: RoundResearchDigest): string;
+    parseMergeReviewResponse(reviewer: string, text: string): ClaimChallenge[];
+    detailExpansionSystemPrompt(): string;
+    detailExpansionUserPrompt(topic: string, phase: ArenaRoadmapPhase, digest: RoundResearchDigest): string;
+    parseDetailExpansionResponse(text: string): ArenaRoadmapPhaseDetail;
+    claimAwareConsensusUserPrompt(topic: string, reports: ParticipantReport[], reviews: FindingReview[], claimSummary: ClaimStatusSummary): string;
+}

package/dist/arena/strategies/review.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Review strategy — structured code review with findings.
+ *
+ * V2: produces ArenaFinding[] (strength/improvement/risk/question)
+ * instead of free-text opinions.
+ */
+import type { ArenaStrategyV2, ArenaBaseContext, ParticipantReport, FindingReview, ArenaConsensus, FindingKind, ClaimRecord, ClaimChallenge, ClaimAdjudication, ClaimStatusSummary, DebateTurn, DebateRound, RoundResearchDigest } from "../types.js";
+export declare class ReviewStrategy implements ArenaStrategyV2 {
+    researchSystemPrompt(name: string): string;
+    researchUserPrompt(topic: string, baseContext: ArenaBaseContext): string;
+    parseResearchResponse(participant: string, text: string): ParticipantReport;
+    crossReviewSystemPrompt(reviewerName: string): string;
+    crossReviewUserPrompt(topic: string, myReport: ParticipantReport, otherReports: ParticipantReport[]): string;
+    parseCrossReviewResponse(reviewer: string, text: string): FindingReview[];
+    consensusSystemPrompt(): string;
+    consensusUserPrompt(topic: string, reports: ParticipantReport[], reviews: FindingReview[]): string;
+    parseConsensusResponse(text: string): ArenaConsensus;
+    preferredFindingKinds(): FindingKind[];
+    verificationReviewUserPrompt(topic: string, myReport: ParticipantReport, claimsToReview: ClaimRecord[], digest: RoundResearchDigest): string;
+    parseVerificationReviewResponse(reviewer: string, text: string): ClaimChallenge[];
+    debateTurnUserPrompt(topic: string, claim: ClaimRecord, priorTurns: DebateTurn[], digest: RoundResearchDigest): string;
+    parseDebateTurnResponse(participant: string, text: string): DebateTurn;
+    adjudicationUserPrompt(topic: string, claim: ClaimRecord, debateRounds: DebateRound[], digest: RoundResearchDigest): string;
+    parseAdjudicationResponse(text: string): ClaimAdjudication;
+    claimAwareConsensusUserPrompt(topic: string, reports: ParticipantReport[], reviews: FindingReview[], claimSummary: ClaimStatusSummary): string;
+}

package/dist/arena/strategies/utils.d.ts

@@ -0,0 +1,34 @@
+/** Shared utilities for arena strategy implementations. */
+import type { ArenaBaseContext, FindingReview, ParticipantReport, ArenaConsensus, ArenaRoadmapPhaseDetail, ClaimRecord, ClaimChallenge, ClaimAdjudication, ClaimStatusSummary, DebateTurn, RoundResearchDigest } from "../types.js";
+/** Extract JSON from text that might have markdown fences or surrounding text */
+export declare function extractJSON(text: string): string;
+/** Extract a JSON array from text */
+export declare function extractJSONArray(text: string): string;
+/** Format base context into a readable text block for LLM prompts */
+export declare function formatBaseContext(ctx: ArenaBaseContext): string;
+/** Format participant reports for cross-review or consensus prompts */
+export declare function formatReports(reports: ParticipantReport[]): string;
+/** Format finding reviews for consensus prompts */
+export declare function formatFindingReviews(reviews: FindingReview[]): string;
+/** Parse a ParticipantReport from LLM JSON output */
+export declare function parseReport(participant: string, text: string): ParticipantReport;
+/** Parse FindingReview[] from LLM JSON output */
+export declare function parseReviews(reviewer: string, text: string): FindingReview[];
+/** Parse ArenaConsensus from LLM JSON output */
+export declare function parseConsensus(text: string): ArenaConsensus;
+/** Format claims for verification-review prompts */
+export declare function formatClaimsForReview(claims: ClaimRecord[]): string;
+/** Format debate history for debate turn prompts */
+export declare function formatDebateHistory(turns: DebateTurn[]): string;
+/** Format claim status summary for consensus prompts */
+export declare function formatClaimSummaryForConsensus(summary: ClaimStatusSummary): string;
+/** Format a digest text block for inclusion in prompts */
+export declare function formatDigestForPrompt(digest: RoundResearchDigest): string;
+/** Parse ClaimChallenge[] from LLM JSON output */
+export declare function parseChallenges(reviewer: string, text: string): ClaimChallenge[];
+/** Parse a DebateTurn from LLM JSON output */
+export declare function parseDebateTurn(participant: string, text: string): DebateTurn;
+/** Parse a ClaimAdjudication from LLM JSON output */
+export declare function parseAdjudication(claimId: string, text: string): ClaimAdjudication;
+/** Parse an ArenaRoadmapPhaseDetail from LLM JSON output */
+export declare function parseDetailExpansion(text: string): ArenaRoadmapPhaseDetail;

package/dist/arena/tools/selector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ArenaToolSelector — selects tool packs based on ArenaPlan sources.
+ *
+ * Maps evidence sources to subsets of the existing context tools.
+ * This replaces the hard-coded "always give all tools" approach.
+ */
+import type { ArenaPlan } from "../types.js";
+import type { ToolDefinition } from "../../types.js";
+/**
+ * Select the appropriate tools for a given plan.
+ * Merges tool packs from all active sources, deduplicating by name.
+ */
+export declare function selectTools(plan: ArenaPlan): ToolDefinition[];
+/**
+ * Check whether any tools are available for the plan.
+ */
+export declare function hasTools(plan: ArenaPlan): boolean;

package/dist/arena/transitions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Claim state machine — centralized transition rules.
+ *
+ * All claim status changes go through this module to enforce
+ * consistent state transitions across phases.
+ *
+ * State machine:
+ *   proposed → under_review
+ *   under_review → verified | contested | rejected
+ *   contested → under_review | unresolved | verified | rejected
+ */
+import type { ClaimRecord, ClaimStatus, ClaimChallenge } from "./types.js";
+/**
+ * Attempt to transition a claim to a new status.
+ * Returns true if the transition was applied, false if invalid.
+ */
+export declare function transitionClaim(claim: ClaimRecord, to: ClaimStatus): boolean;
+/**
+ * Determine the next status for a claim based on its challenges.
+ *
+ * Rules:
+ * - No challenges → stays as-is (unreviewed is NOT verified)
+ * - Any "disagree" → contested
+ * - Any "needs_evidence" → contested
+ * - Pending checks exist → contested
+ * - At least one explicit "agree" and all others "agree"/"refine" → verified
+ */
+export declare function resolveClaimStatus(claim: ClaimRecord, challenges: ClaimChallenge[], hasPendingChecks: boolean): ClaimStatus;
+/**
+ * Mark a claim as entering review.
+ */
+export declare function markUnderReview(claim: ClaimRecord): boolean;
+/**
+ * Apply review results to a claim and transition appropriately.
+ */
+export declare function applyReviewResult(claim: ClaimRecord, challenges: ClaimChallenge[], hasPendingChecks: boolean): void;
+/**
+ * Mark a contested claim as unresolved (budget/round exhausted).
+ */
+export declare function markUnresolved(claim: ClaimRecord): boolean;
+/**
+ * Check if a claim is in a terminal state (no further transitions possible).
+ */
+export declare function isTerminal(claim: ClaimRecord): boolean;
+/**
+ * Get valid next statuses for a claim.
+ */
+export declare function validTransitions(claim: ClaimRecord): ClaimStatus[];