@cjhyy/code-shell-arena 0.8.0

package/dist/render/terminal.js

@@ -0,0 +1,286 @@
+/**
+ * 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 { NOOP_COLORIZER } from "@cjhyy/code-shell-core/extension";
+/**
+ * Format the full arena result as a styled string.
+ */
+export function formatArenaResult(result, c = NOOP_COLORIZER) {
+    const modeLabel = result.mode.charAt(0).toUpperCase() + result.mode.slice(1);
+    const lines = [];
+    lines.push("");
+    lines.push(c.bold(`  ═══ ${modeLabel} Conclusion ═══`));
+    lines.push("");
+    // Summary
+    if (result.consensus.summary) {
+        lines.push(`  ${result.consensus.summary}`);
+        lines.push("");
+    }
+    // Roadmap first for planning scenes
+    if (result.mode === "planning") {
+        lines.push(...formatRoadmapSection(result.consensus.roadmap, c));
+        if (result.consensus.roadmapDetails && result.consensus.roadmapDetails.length > 0) {
+            lines.push(...formatRoadmapDetailsSection(result.consensus.roadmapDetails, c));
+        }
+    }
+    // Consensus sections ordered by output emphasis
+    for (const section of getOrderedConsensusSections(result, c)) {
+        lines.push(...formatConsensusSection(section.title, section.items, section.color, section.icon, c));
+    }
+    // Roadmap after findings for non-planning scenes
+    if (result.mode !== "planning") {
+        lines.push(...formatRoadmapSection(result.consensus.roadmap, c));
+    }
+    // Next Actions
+    if (result.consensus.nextActions.length > 0) {
+        lines.push(c.boldWhite("\n  Next Actions:"));
+        for (const action of result.consensus.nextActions) {
+            const pri = action.priority === "high"
+                ? c.red("HIGH")
+                : action.priority === "medium"
+                    ? c.yellow("MED")
+                    : c.dim("LOW");
+            lines.push(`    ${c.white("→")} [${pri}${c.white("]")} ${action.title}`);
+            if (action.rationale) {
+                lines.push(c.dim(`      ${action.rationale}`));
+            }
+        }
+    }
+    // Footer
+    lines.push("");
+    const planInfo = result.plan
+        ? ` | Lenses: ${result.plan.lenses.map((l) => l.name).join(", ")} | Sources: ${result.plan.sources.map((s) => s.kind).join(", ")}`
+        : "";
+    lines.push(c.dim(`  Mode: ${modeLabel} | ` +
+        `Findings: ${countFindings(result)} | ` +
+        `Models: ${result.participants.join(", ")}` +
+        planInfo));
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Print the full arena result directly to stdout.
+ * Used by the CLI `code-shell arena` command (non-REPL).
+ */
+export function printArenaResult(result, c = NOOP_COLORIZER) {
+    console.log(formatArenaResult(result, c));
+}
+function formatConsensusSection(title, items, color, icon, c) {
+    if (items.length === 0)
+        return [];
+    const lines = [];
+    lines.push(color(`\n  ${title}:`));
+    for (const item of items) {
+        lines.push(color(`    ${icon} ${item.title}`));
+        if (item.summary) {
+            lines.push(c.dim(`      ${item.summary}`));
+        }
+        if (item.challenge.length > 0) {
+            lines.push(c.dim(`      Challenged by: ${item.challenge.join(", ")}`));
+        }
+    }
+    return lines;
+}
+function countFindings(result) {
+    return result.reports.reduce((sum, r) => sum + r.findings.length, 0);
+}
+function formatRoadmapSection(phases, c) {
+    if (phases.length === 0)
+        return [];
+    const lines = [];
+    lines.push(c.boldWhite("\n  Roadmap:"));
+    for (const [index, phase] of phases.entries()) {
+        const pri = phase.priority === "high"
+            ? c.red("HIGH")
+            : phase.priority === "medium"
+                ? c.yellow("MED")
+                : c.dim("LOW");
+        lines.push(`    ${c.white("→")} Phase ${index + 1}: ${phase.title} [${pri}${c.white("]")}`);
+        if (phase.goal) {
+            lines.push(c.dim(`      Goal: ${phase.goal}`));
+        }
+        if (phase.scope.length > 0) {
+            lines.push(c.dim(`      Scope: ${phase.scope.join("; ")}`));
+        }
+        if (phase.deliverables.length > 0) {
+            lines.push(c.dim(`      Deliverables: ${phase.deliverables.join("; ")}`));
+        }
+        if (phase.dependencies.length > 0) {
+            lines.push(c.dim(`      Dependencies: ${phase.dependencies.join("; ")}`));
+        }
+        if (phase.risks.length > 0) {
+            lines.push(c.dim(`      Risks: ${phase.risks.join("; ")}`));
+        }
+        if (phase.successCriteria.length > 0) {
+            lines.push(c.dim(`      Success: ${phase.successCriteria.join("; ")}`));
+        }
+    }
+    return lines;
+}
+function formatRoadmapDetailsSection(details, c) {
+    const lines = [];
+    lines.push(c.boldWhite("\n  Implementation Details:"));
+    for (const detail of details) {
+        const effort = detail.effort === "large"
+            ? c.red("L")
+            : detail.effort === "medium"
+                ? c.yellow("M")
+                : c.green("S");
+        lines.push(`\n    ${c.white("▸")} ${detail.phaseTitle} [${effort}]`);
+        if (detail.objective) {
+            lines.push(c.dim(`      ${detail.objective}`));
+        }
+        if (detail.targetFiles.length > 0) {
+            lines.push(c.dim(`      Files: ${detail.targetFiles.join(", ")}`));
+        }
+        if (detail.codeChanges.length > 0) {
+            for (const change of detail.codeChanges) {
+                lines.push(c.dim(`      • ${change}`));
+            }
+        }
+        if (detail.interfaces.length > 0) {
+            lines.push(c.dim(`      Interfaces: ${detail.interfaces.join("; ")}`));
+        }
+        if (detail.migrationSteps.length > 0) {
+            lines.push(c.dim(`      Migration:`));
+            for (const [i, step] of detail.migrationSteps.entries()) {
+                lines.push(c.dim(`        ${i + 1}. ${step}`));
+            }
+        }
+        if (detail.validation.length > 0) {
+            lines.push(c.dim(`      Validation: ${detail.validation.join("; ")}`));
+        }
+        if (detail.blockers.length > 0) {
+            lines.push(c.red(`      Blockers: ${detail.blockers.join("; ")}`));
+        }
+    }
+    return lines;
+}
+function getOrderedConsensusSections(result, c) {
+    const VALID_KINDS = new Set(["strength", "improvement", "risk", "question"]);
+    const defaultOrder = ["risk", "improvement", "strength", "question"];
+    const emphasize = (result.plan?.outputShape?.emphasize ?? []).filter((k) => VALID_KINDS.has(k));
+    const orderedKinds = dedupeFindingKinds([...emphasize, ...defaultOrder]);
+    return orderedKinds
+        .map((kind) => {
+        switch (kind) {
+            case "strength":
+                return { kind, title: "Strengths", items: result.consensus.strengths, color: c.green.bind(c), icon: "✓" };
+            case "improvement":
+                return { kind, title: "Improvements", items: result.consensus.improvements, color: c.yellow.bind(c), icon: "→" };
+            case "risk":
+                return { kind, title: "Risks", items: result.consensus.risks, color: c.red.bind(c), icon: "⚠" };
+            case "question":
+                return { kind, title: "Open Questions", items: result.consensus.openQuestions, color: c.cyan.bind(c), icon: "?" };
+        }
+    })
+        .filter((section) => section != null)
+        .filter((section) => section.items.length > 0);
+}
+function dedupeFindingKinds(kinds) {
+    const seen = new Set();
+    const result = [];
+    for (const kind of kinds) {
+        if (!seen.has(kind)) {
+            seen.add(kind);
+            result.push(kind);
+        }
+    }
+    return result;
+}
+/**
+ * Create a progress renderer that sends output to a sink.
+ * For REPL: pass ctx.addStatus. For CLI: pass console.log.
+ */
+export function createProgressRenderer(sink, c = NOOP_COLORIZER) {
+    return (event) => {
+        switch (event.type) {
+            case "plan_resolved":
+                sink(c.dim(`Plan: ${event.plan.mode} | ` +
+                    `lenses: ${event.plan.lenses.map((l) => l.name).join(", ")} | ` +
+                    `sources: ${event.plan.sources.map((s) => s.kind).join(", ")}` +
+                    (event.plan.confidence !== "high" ? ` (${event.plan.confidence} confidence)` : "")));
+                break;
+            case "evidence_started":
+                sink(c.dim(`  · collecting from ${event.source}…`));
+                break;
+            case "evidence_source_done": {
+                const tag = event.timedOut ? c.yellow(" (timed out)") : "";
+                sink(c.dim(`  · ${event.source}: ${event.count} artifacts in ${event.durationMs}ms${tag}`));
+                break;
+            }
+            case "evidence_collected":
+                sink(c.dim(`Evidence: ${event.artifacts.length} artifacts collected`));
+                break;
+            case "research_start":
+                sink(c.dim(`⏳ ${event.participant} researching...`));
+                break;
+            case "research_done": {
+                const fCount = event.report.findings.length;
+                sink(`${event.participant}: ${c.green("done")} (${fCount} findings)`);
+                break;
+            }
+            case "context_lookup":
+                for (const t of event.tools) {
+                    sink(c.dim(`  🔍 ${event.participant}: ${t}`));
+                }
+                break;
+            case "claims_registered":
+                sink(c.dim(`${event.claimCount} claims registered`));
+                break;
+            case "cross_review_start":
+                sink(c.dim("── Cross Review ──"));
+                break;
+            case "cross_review_done":
+                sink(c.dim(`${event.reviews.length} peer reviews collected`));
+                break;
+            case "verification_start":
+                sink(c.dim("── Verification Review ──"));
+                break;
+            case "verification_done":
+                sink(c.dim(`${event.challengeCount} challenges raised`));
+                break;
+            case "debate_round_start":
+                sink(c.dim(`── Debate Round ${event.round} (${event.claims.length} claims) ──`));
+                break;
+            case "debate_round_done":
+                sink(c.dim(`Round ${event.round}: ${event.resolved} resolved`));
+                break;
+            case "adjudication_done":
+                sink(c.dim(`Adjudication: ${event.accepted} accepted, ${event.unresolved} unresolved`));
+                break;
+            case "planning_merge_review_start":
+                sink(c.dim("── Planning Merge Review ──"));
+                break;
+            case "planning_merge_review_done":
+                sink(c.dim(`${event.mergeCount} merge suggestions collected`));
+                break;
+            case "roadmap_expansion_start":
+                sink(c.dim(`── Expanding ${event.phaseCount} roadmap phases ──`));
+                break;
+            case "roadmap_expansion_done":
+                sink(c.dim(`${event.detailCount} phase details generated`));
+                break;
+            case "consensus_start":
+                sink(c.dim("⏳ Building consensus..."));
+                break;
+            case "consensus_done":
+                break;
+        }
+    };
+}
+/**
+ * Legacy: direct console.log progress renderer for CLI mode.
+ */
+export function renderProgress(event, c = NOOP_COLORIZER) {
+    createProgressRenderer((text) => console.log(`  ${text}`), c)(event);
+}

package/dist/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/strategies/discussion.js

@@ -0,0 +1,143 @@
+/**
+ * Discussion strategy — open-ended debate with structured findings.
+ *
+ * V2: focuses on trade-offs, competing viewpoints, and evidence-backed arguments.
+ */
+import { formatBaseContext, formatReports, formatFindingReviews, formatClaimsForReview, formatDebateHistory, formatClaimSummaryForConsensus, formatDigestForPrompt, parseReport, parseReviews, parseConsensus, parseChallenges, parseDebateTurn, parseAdjudication, } from "./utils.js";
+export class DiscussionStrategy {
+    researchSystemPrompt(name) {
+        return (`You are ${name}, participating in a multi-model discussion arena.\n\n` +
+            `You may have access to read-only tools to gather evidence. ` +
+            `The base context is intentionally lean — use tools as needed.\n\n` +
+            `IMPORTANT RULES:\n` +
+            `- Limit yourself to 3-5 tool rounds. Do NOT exhaustively read every file.\n` +
+            `- Output as many findings as the topic warrants — typically 5-15 for a non-trivial subject. ` +
+            `Each finding's "summary" should be 80+ words with concrete evidence and rationale, not a one-liner. ` +
+            `Rank by confidence.\n` +
+            `- Focus on trade-offs, risks, and open questions. Strengths are optional.\n\n` +
+            `Respond ONLY with JSON (no markdown fences):\n` +
+            `{"contextSummary": "what you investigated and your overall take",` +
+            ` "findings": [{"id": "unique-id", "kind": "risk|improvement|question|strength",` +
+            ` "title": "short title", "summary": "detailed analysis with evidence",` +
+            ` "severity": "high|medium|low", "confidence": 0.0-1.0,` +
+            ` "evidence": [{"type": "file|diff|grep|git|doc", "ref": "path", "note": "what it shows"}],` +
+            ` "affectedFiles": ["paths"], "suggestedChange": "optional"}]}`);
+    }
+    researchUserPrompt(topic, baseContext) {
+        return (`## Discussion Topic\n${topic}\n\n` +
+            `${formatBaseContext(baseContext)}\n\n` +
+            `Use tools to investigate, then output 3-6 highest-confidence findings as JSON.`);
+    }
+    parseResearchResponse(participant, text) {
+        return parseReport(participant, text);
+    }
+    crossReviewSystemPrompt(reviewerName) {
+        return (`You are ${reviewerName}, reviewing other participants' discussion findings.\n\n` +
+            `Engage thoughtfully: challenge weak arguments, acknowledge strong ones.\n` +
+            `Focus on finding the best answer, not winning.\n\n` +
+            `For each finding you want to address, provide a verdict:\n` +
+            `- "agree": you confirm this perspective\n` +
+            `- "refine": mostly agree but with nuances\n` +
+            `- "disagree": you have a different view with evidence\n` +
+            `- "needs_evidence": the claim lacks supporting evidence\n\n` +
+            `Respond ONLY with a JSON array:\n` +
+            `[{"findingId": "...", "verdict": "...", "reason": "...", "extraEvidence": ["optional"]}]`);
+    }
+    crossReviewUserPrompt(topic, myReport, otherReports) {
+        return (`## Topic: ${topic}\n\n` +
+            `## Your Analysis\n${formatReports([myReport])}\n\n` +
+            `## Other Participants' Analysis\n${formatReports(otherReports)}\n\n` +
+            `Review the others' findings. Where do you agree or disagree? What nuances are missing?`);
+    }
+    parseCrossReviewResponse(reviewer, text) {
+        return parseReviews(reviewer, text);
+    }
+    consensusSystemPrompt() {
+        return (`You are a neutral moderator synthesizing a multi-model discussion into a balanced conclusion.\n\n` +
+            `Capture key insights, agreements, and remaining disagreements. ` +
+            `Do NOT suppress minority viewpoints — preserve them as open questions.\n\n` +
+            `IMPORTANT: Start with a "subjectSummary" — a factual framing of the topic, current scope, or assumptions under discussion before moving into conclusions.\n\n` +
+            `Respond ONLY with JSON (no markdown fences):\n` +
+            `{\n` +
+            `  "summary": "balanced synthesis",\n` +
+            `  "subjectSummary": "factual problem framing or current scope of the discussion",\n` +
+            `  "strengths": [{"title": "...", "summary": "...", "support": [], "challenge": [], "confidence": 0.0-1.0, "evidenceRefs": []}],\n` +
+            `  "improvements": [same structure],\n` +
+            `  "risks": [same structure],\n` +
+            `  "openQuestions": [same structure — include still-debated points],\n` +
+            `  "nextActions": [{"title": "...", "priority": "high|medium|low", "rationale": "...", "relatedFindings": []}]\n` +
+            `}`);
+    }
+    consensusUserPrompt(topic, reports, reviews) {
+        return (`## Topic\n${topic}\n\n` +
+            `## Participant Analyses\n${formatReports(reports)}\n\n` +
+            `## Peer Reviews\n${formatFindingReviews(reviews)}\n\n` +
+            `Synthesize a balanced conclusion. Start with a factual subjectSummary, then preserve disagreements as open questions.`);
+    }
+    parseConsensusResponse(text) {
+        return parseConsensus(text);
+    }
+    preferredFindingKinds() {
+        return ["strength", "risk", "question"];
+    }
+    // ─── V2: Verification Review ────────────────────────────────────
+    verificationReviewUserPrompt(topic, myReport, claimsToReview, digest) {
+        return (`## Topic: ${topic}\n\n` +
+            `## Your Analysis\n${formatReports([myReport])}\n\n` +
+            `## Claims to Verify\n${formatClaimsForReview(claimsToReview)}\n\n` +
+            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
+            `Engage critically with each claim. Challenge weak arguments, acknowledge strong ones. ` +
+            `Focus on finding the best answer, not winning.\n` +
+            `Respond ONLY with a JSON array:\n` +
+            `[{"claimId": "...", "verdict": "agree|refine|disagree|needs_evidence", "reason": "...", ` +
+            `"supportingEvidenceRefs": ["optional"], "requestedChecks": [{"description": "what to check", "priority": "high|medium|low"}]}]`);
+    }
+    parseVerificationReviewResponse(reviewer, text) {
+        return parseChallenges(reviewer, text);
+    }
+    // ─── V2: Debate ─────────────────────────────────────────────────
+    debateTurnUserPrompt(topic, claim, priorTurns, digest) {
+        return (`## Topic: ${topic}\n\n` +
+            `## Contested Claim\n` +
+            `[${claim.claimId}] ${claim.finding.title}\n${claim.finding.summary}\n\n` +
+            `## Prior Debate\n${formatDebateHistory(priorTurns)}\n\n` +
+            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
+            `Engage thoughtfully. If the evidence supports the claim, narrow toward agreement. ` +
+            `If not, explain why with evidence.\n` +
+            `Respond ONLY with JSON:\n` +
+            `{"stance": "support|oppose|narrow|uncertain", "summary": "your argument", "newEvidenceRefs": ["optional"]}`);
+    }
+    parseDebateTurnResponse(participant, text) {
+        return parseDebateTurn(participant, text);
+    }
+    // ─── V2: Adjudication ──────────────────────────────────────────
+    adjudicationUserPrompt(topic, claim, debateRounds, digest) {
+        const debateSummary = debateRounds.length > 0
+            ? debateRounds.map((r) => `Round ${r.round}:\n${formatDebateHistory(r.participants)}\n${r.resolved ? "→ Resolved" : "→ Unresolved"}`).join("\n\n")
+            : "No debate rounds occurred.";
+        return (`## Topic: ${topic}\n\n` +
+            `## Contested Claim\n` +
+            `[${claim.claimId}] ${claim.finding.title}\n${claim.finding.summary}\n` +
+            `Owner: ${claim.owner}\n\n` +
+            `## Challenges\n` +
+            claim.challenges.map((c) => `[${c.reviewer}] ${c.verdict}: ${c.reason}`).join("\n") + "\n\n" +
+            `## Debate\n${debateSummary}\n\n` +
+            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
+            `As moderator, synthesize the debate. Preserve minority viewpoints where the evidence is genuinely ambiguous.\n` +
+            `Respond ONLY with JSON:\n` +
+            `{"outcome": "accepted|accepted_with_revision|rejected|unresolved", "rationale": "...", ` +
+            `"finalSummary": "revised claim summary", "supportingEvidenceRefs": ["..."]}`);
+    }
+    parseAdjudicationResponse(text) {
+        return parseAdjudication("", text);
+    }
+    // ─── V2: Claim-Aware Consensus ─────────────────────────────────
+    claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary) {
+        return (`## Topic\n${topic}\n\n` +
+            `## Claim Verification Status\n${formatClaimSummaryForConsensus(claimSummary)}\n\n` +
+            `## Participant Analyses\n${formatReports(reports)}\n\n` +
+            `## Peer Reviews\n${formatFindingReviews(reviews)}\n\n` +
+            `Synthesize a balanced conclusion. Verified claims are high-confidence. ` +
+            `Unresolved claims should be preserved as open questions — do NOT suppress minority viewpoints.`);
+    }
+}

package/dist/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/strategies/index.js

@@ -0,0 +1,28 @@
+/**
+ * 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 { ReviewStrategy } from "./review.js";
+import { DiscussionStrategy } from "./discussion.js";
+import { PlanningStrategy } from "./planning.js";
+import { withLens } from "./lens-wrapper.js";
+const STRATEGY_MAP = {
+    review: () => new ReviewStrategy(),
+    discussion: () => new DiscussionStrategy(),
+    planning: () => new PlanningStrategy(),
+};
+/** Get the default strategy for a given arena mode. */
+export function getStrategy(mode) {
+    return STRATEGY_MAP[mode]();
+}
+/**
+ * Get a strategy for a plan — mode strategy + lens wrapper.
+ * This is the new evidence-driven entry point.
+ */
+export function getStrategyForPlan(plan) {
+    const base = STRATEGY_MAP[plan.mode]();
+    return withLens(base, plan);
+}

package/dist/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/strategies/language-wrapper.js

@@ -0,0 +1,102 @@
+/**
+ * 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 { isStrategyV2 } from "../types.js";
+/**
+ * Detect whether the topic is primarily non-English.
+ * Returns a language instruction string, or empty if English.
+ */
+export function detectLanguageInstruction(topic) {
+    // Simple heuristic: count CJK / Cyrillic / Arabic / Thai / Korean characters
+    // vs ASCII. If non-ASCII ratio is significant, infer the language.
+    const nonAscii = topic.replace(/[\x00-\x7F]/g, "");
+    const ratio = nonAscii.length / Math.max(topic.length, 1);
+    if (ratio < 0.15)
+        return ""; // predominantly English/ASCII
+    // Detect specific scripts
+    if (/[\u4e00-\u9fff\u3400-\u4dbf]/.test(topic)) {
+        return "IMPORTANT: The user's query is in Chinese. You MUST respond in Chinese (中文). All text output — summaries, findings, titles, descriptions, rationale — must be written in Chinese. JSON field values must be in Chinese.";
+    }
+    if (/[\u3040-\u309f\u30a0-\u30ff]/.test(topic)) {
+        return "IMPORTANT: The user's query is in Japanese. You MUST respond in Japanese (日本語). All text output must be in Japanese. JSON field values must be in Japanese.";
+    }
+    if (/[\uac00-\ud7af]/.test(topic)) {
+        return "IMPORTANT: The user's query is in Korean. You MUST respond in Korean (한국어). All text output must be in Korean. JSON field values must be in Korean.";
+    }
+    if (/[\u0400-\u04ff]/.test(topic)) {
+        return "IMPORTANT: The user's query is in Russian. You MUST respond in Russian (русский). All text output must be in Russian. JSON field values must be in Russian.";
+    }
+    if (/[\u0600-\u06ff]/.test(topic)) {
+        return "IMPORTANT: The user's query is in Arabic. You MUST respond in Arabic (العربية). All text output must be in Arabic. JSON field values must be in Arabic.";
+    }
+    // Generic fallback for other non-ASCII scripts
+    return "IMPORTANT: Respond in the same language as the user's query. All text output — summaries, findings, titles, descriptions — must match the query language.";
+}
+/**
+ * Wrap a strategy to inject language instructions into all system prompts.
+ * If the topic is English, returns the original strategy unchanged.
+ */
+export function withLanguage(strategy, topic) {
+    const langInstruction = detectLanguageInstruction(topic);
+    if (!langInstruction)
+        return strategy;
+    return {
+        researchSystemPrompt(name) {
+            return `${langInstruction}\n\n${strategy.researchSystemPrompt(name)}`;
+        },
+        researchUserPrompt(t, ctx) {
+            return strategy.researchUserPrompt(t, ctx);
+        },
+        parseResearchResponse(participant, text) {
+            return strategy.parseResearchResponse(participant, text);
+        },
+        crossReviewSystemPrompt(reviewerName) {
+            return `${langInstruction}\n\n${strategy.crossReviewSystemPrompt(reviewerName)}`;
+        },
+        crossReviewUserPrompt(t, my, others) {
+            return strategy.crossReviewUserPrompt(t, my, others);
+        },
+        parseCrossReviewResponse(reviewer, text) {
+            return strategy.parseCrossReviewResponse(reviewer, text);
+        },
+        consensusSystemPrompt() {
+            return `${langInstruction}\n\n${strategy.consensusSystemPrompt()}`;
+        },
+        consensusUserPrompt(t, reports, reviews) {
+            return strategy.consensusUserPrompt(t, reports, reviews);
+        },
+        parseConsensusResponse(text) {
+            return strategy.parseConsensusResponse(text);
+        },
+        preferredFindingKinds() {
+            return strategy.preferredFindingKinds();
+        },
+        // ─── V2 forwarding (conditional) ─────────────────────────────
+        ...(isStrategyV2(strategy) ? {
+            verificationReviewUserPrompt(topic, myReport, claims, digest) {
+                return strategy.verificationReviewUserPrompt(topic, myReport, claims, digest);
+            },
+            parseVerificationReviewResponse(reviewer, text) {
+                return strategy.parseVerificationReviewResponse(reviewer, text);
+            },
+            debateTurnUserPrompt(topic, claim, priorTurns, digest) {
+                return strategy.debateTurnUserPrompt(topic, claim, priorTurns, digest);
+            },
+            parseDebateTurnResponse(participant, text) {
+                return strategy.parseDebateTurnResponse(participant, text);
+            },
+            adjudicationUserPrompt(topic, claim, rounds, digest) {
+                return strategy.adjudicationUserPrompt(topic, claim, rounds, digest);
+            },
+            parseAdjudicationResponse(text) {
+                return strategy.parseAdjudicationResponse(text);
+            },
+            claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary) {
+                return strategy.claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary);
+            },
+        } : {}),
+    };
+}

package/dist/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;