@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-SQZHPD3S.js

@@ -0,0 +1,4577 @@
+import {
+  logger
+} from "./chunk-X4HAERTQ.js";
+import {
+  LLMError
+} from "./chunk-FUOKLKR2.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/llm/client-factory.ts
+init_esm_shims();
+var PROVIDER_REGISTRY = /* @__PURE__ */ new Map();
+function registerProvider(name, cls) {
+  PROVIDER_REGISTRY.set(name, cls);
+}
+async function createLLMClient(config) {
+  let Cls = PROVIDER_REGISTRY.get(config.provider);
+  if (!Cls) {
+    if (config.provider === "anthropic") {
+      const { AnthropicClient } = await import("./anthropic-NENYS535.js");
+      registerProvider("anthropic", AnthropicClient);
+      Cls = AnthropicClient;
+    } else if (config.provider === "openai") {
+      const { OpenAIClient } = await import("./openai-5HQGBL4L.js");
+      registerProvider("openai", OpenAIClient);
+      Cls = OpenAIClient;
+    }
+  }
+  if (!Cls) {
+    throw new LLMError(
+      `Unknown LLM provider: ${config.provider}. Available: ${[...PROVIDER_REGISTRY.keys()].join(", ")}`
+    );
+  }
+  return new Cls(config);
+}
+
+// src/arena/types.ts
+init_esm_shims();
+var ARENA_MODE_DEFAULTS = {
+  review: { maxDiscussionRounds: 3, convergenceThreshold: 200 },
+  discussion: { maxDiscussionRounds: 4, convergenceThreshold: 300 },
+  planning: { maxDiscussionRounds: 5, convergenceThreshold: 400 }
+};
+var DEFAULT_EXECUTION_LIMITS = {
+  maxClaimsForReview: 12,
+  maxContestedClaimsForDebate: 5,
+  maxRequestedChecksPerClaimPerRound: 2,
+  maxReviewersPerClaim: 2,
+  maxRoadmapPhases: 6,
+  maxExpandedPhasesPerRun: 6
+};
+function isStrategyPlanning(s) {
+  return typeof s.detailExpansionUserPrompt === "function";
+}
+function isStrategyV2(s) {
+  return typeof s.verificationReviewUserPrompt === "function";
+}
+
+// src/arena/strategies/review.ts
+init_esm_shims();
+
+// src/arena/strategies/utils.ts
+init_esm_shims();
+function asString(v) {
+  if (typeof v === "string") return v;
+  if (v == null) return "";
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  return "";
+}
+function sanitizeForPrompt(text) {
+  if (!text) return "";
+  return text.replace(/<\/?(?:system|assistant|user|system-reminder)[^>]*>/gi, "").replace(/^(?:IGNORE|DISREGARD|FORGET|OVERRIDE|SYSTEM|INSTRUCTION)[:\s].*/gim, "").slice(0, 3e3);
+}
+function extractJSON(text) {
+  const fenced = text.match(/```(?:json)?\s*\n([\s\S]*)\n\s*```/);
+  if (fenced) return fenced[1].trim();
+  const start = text.indexOf("{");
+  if (start !== -1) {
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{") depth++;
+      else if (ch === "}") {
+        depth--;
+        if (depth === 0) return text.slice(start, i + 1);
+      }
+    }
+    return text.slice(start);
+  }
+  return text;
+}
+function extractJSONArray(text) {
+  const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenced) return fenced[1].trim();
+  const arrayMatch = text.match(/\[[\s\S]*\]/);
+  if (arrayMatch) return arrayMatch[0];
+  return text;
+}
+function formatBaseContext(ctx) {
+  const sections = [];
+  if (ctx.quickFacts.length > 0) {
+    sections.push(`## Quick Facts
+${ctx.quickFacts.map((f) => `- ${f.label}: ${f.value}`).join("\n")}`);
+  }
+  for (const artifact of ctx.artifacts) {
+    const header = artifact.ref ? `${artifact.title} (${artifact.ref})` : artifact.title;
+    sections.push(`## ${artifact.kind.toUpperCase()}: ${header}
+\`\`\`
+${artifact.preview}
+\`\`\``);
+  }
+  return sections.join("\n\n");
+}
+function formatReports(reports) {
+  return reports.map((r) => {
+    const findingsList = r.findings.map(
+      (f) => `  - [${f.id}] (${f.kind}${f.severity ? `, ${f.severity}` : ""}) ${f.title}
+    ${f.summary}
+    Evidence: ${f.evidence.map((e) => `${e.type}:${e.ref}`).join(", ")}
+    Confidence: ${f.confidence}` + (f.suggestedChange ? `
+    Suggested: ${f.suggestedChange}` : "")
+    ).join("\n");
+    return `### ${r.participant}
+${r.contextSummary}
+
+Findings:
+${findingsList}`;
+  }).join("\n\n");
+}
+function formatFindingReviews(reviews) {
+  if (reviews.length === 0) return "No peer reviews.";
+  return reviews.map(
+    (r) => `[${r.reviewer}] on ${r.findingId}: ${r.verdict}${r.reason ? ` \u2014 ${r.reason}` : ""}`
+  ).join("\n");
+}
+function parseReport(participant, text) {
+  if (!text || text.trim().length === 0) {
+    logger.warn("arena.parse_report_empty", { participant });
+    return {
+      participant,
+      contextSummary: "(no response)",
+      findings: []
+    };
+  }
+  try {
+    const json = extractJSON(text);
+    const parsed = JSON.parse(json);
+    let findings = parsed.findings;
+    if (!Array.isArray(findings) && parsed.contextSummary === void 0) {
+      if (parsed.kind && parsed.title) {
+        findings = [parsed];
+      }
+    }
+    const report = {
+      participant,
+      contextSummary: parsed.contextSummary ?? parsed.context_summary ?? "",
+      findings: Array.isArray(findings) ? findings.map(parseFinding) : []
+    };
+    if (report.findings.length === 0) {
+      logger.warn("arena.parse_report_no_findings", {
+        participant,
+        textPreview: text.slice(0, 200)
+      });
+    }
+    return report;
+  } catch (err) {
+    logger.warn("arena.parse_report_json_fail", {
+      participant,
+      error: err.message,
+      textLength: text.length,
+      text: text.slice(0, 2e3)
+    });
+    return extractFindingsFromFreeText(participant, text);
+  }
+}
+function parseFinding(raw, index) {
+  return {
+    id: asString(raw.id) || `f${index + 1}`,
+    kind: validateFindingKind(raw.kind),
+    title: asString(raw.title) || "Untitled",
+    summary: asString(raw.summary),
+    severity: raw.severity || void 0,
+    confidence: typeof raw.confidence === "number" ? raw.confidence : 0.5,
+    evidence: Array.isArray(raw.evidence) ? raw.evidence.map((e) => ({
+      type: e.type ?? "doc",
+      ref: e.ref ?? "",
+      note: e.note ?? ""
+    })) : [],
+    affectedFiles: Array.isArray(raw.affectedFiles) ? raw.affectedFiles : [],
+    suggestedChange: raw.suggestedChange || void 0
+  };
+}
+function validateFindingKind(v) {
+  if (v === "strength" || v === "improvement" || v === "risk" || v === "question") return v;
+  return "improvement";
+}
+function extractFindingsFromFreeText(participant, text) {
+  const sections = text.split(/(?:^|\n)(?:#{1,3}\s+|\d+\.\s+|\*\*[^*]+\*\*\s*\n|---+\s*\n)/m).map((s) => s.trim()).filter((s) => s.length > 20);
+  if (sections.length === 0) {
+    return {
+      participant,
+      contextSummary: text.slice(0, 200),
+      findings: [{
+        id: `${participant}-f1`,
+        kind: "improvement",
+        title: "Analysis",
+        summary: text.slice(0, 3e3),
+        confidence: 0.5,
+        evidence: [],
+        affectedFiles: []
+      }]
+    };
+  }
+  const findings = sections.slice(0, 10).map((section, i) => {
+    const firstLine = section.split("\n")[0].slice(0, 100);
+    const body = section.length > firstLine.length ? section.slice(firstLine.length).trim() : section;
+    return {
+      id: `${participant}-f${i + 1}`,
+      kind: classifyFindingKind(section),
+      title: firstLine.replace(/^[-*•]\s*/, "").replace(/\*\*/g, ""),
+      summary: body.slice(0, 1e3),
+      confidence: 0.5,
+      evidence: [],
+      affectedFiles: extractFilePaths(section)
+    };
+  });
+  return {
+    participant,
+    contextSummary: text.slice(0, 200),
+    findings
+  };
+}
+function classifyFindingKind(text) {
+  const lower = text.toLowerCase();
+  if (/\b(risk|danger|vulnerab|security|breaking|regression|critical)\b/.test(lower)) return "risk";
+  if (/\b(good|well|strength|clean|solid|nice|excellent|properly)\b/.test(lower)) return "strength";
+  if (/\b(question|unclear|confirm|clarif|why|how come|wonder)\b/.test(lower)) return "question";
+  return "improvement";
+}
+function extractFilePaths(text) {
+  const matches = text.match(/(?:^|\s)((?:src|lib|packages|app)\/[\w\-/.]+\.\w+)/gm);
+  return matches ? [...new Set(matches.map((m) => m.trim()))] : [];
+}
+function parseReviews(reviewer, text) {
+  try {
+    const json = extractJSONArray(text);
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed)) {
+      const objJson = extractJSON(text);
+      const obj = JSON.parse(objJson);
+      if (Array.isArray(obj.reviews)) {
+        return obj.reviews.map((r) => parseReview(reviewer, r));
+      }
+      return [];
+    }
+    return parsed.map((r) => parseReview(reviewer, r));
+  } catch {
+    return [];
+  }
+}
+function parseReview(reviewer, raw) {
+  return {
+    reviewer,
+    findingId: raw.findingId ?? raw.finding_id ?? "",
+    verdict: validateVerdict(raw.verdict),
+    reason: raw.reason ?? "",
+    extraEvidence: Array.isArray(raw.extraEvidence) ? raw.extraEvidence : void 0
+  };
+}
+function validateVerdict(v) {
+  if (v === "agree" || v === "refine" || v === "disagree" || v === "needs_evidence") return v;
+  return "agree";
+}
+function parseConsensus(text) {
+  try {
+    const json = extractJSON(text);
+    const parsed = JSON.parse(json);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("parsed JSON is not an object");
+    }
+    return {
+      summary: asString(parsed.summary),
+      subjectSummary: asString(parsed.subjectSummary || parsed.changeSummary) || void 0,
+      strengths: parseConsensusItems(parsed.strengths),
+      improvements: parseConsensusItems(parsed.improvements),
+      risks: parseConsensusItems(parsed.risks),
+      openQuestions: parseConsensusItems(parsed.openQuestions),
+      roadmap: parseRoadmapPhases(parsed.roadmap),
+      nextActions: Array.isArray(parsed.nextActions) ? parsed.nextActions.map((a) => ({
+        title: a.title ?? "",
+        priority: validatePriority(a.priority),
+        rationale: a.rationale ?? "",
+        relatedFindings: Array.isArray(a.relatedFindings) ? a.relatedFindings : []
+      })) : []
+    };
+  } catch {
+    return {
+      summary: text,
+      strengths: [],
+      improvements: [],
+      risks: [],
+      openQuestions: [],
+      roadmap: [],
+      nextActions: []
+    };
+  }
+}
+function parseConsensusItems(arr) {
+  if (!Array.isArray(arr)) return [];
+  return arr.map((item) => ({
+    title: asString(item.title),
+    summary: item.summary ?? "",
+    support: Array.isArray(item.support) ? item.support : [],
+    challenge: Array.isArray(item.challenge) ? item.challenge : [],
+    confidence: typeof item.confidence === "number" ? item.confidence : 0.5,
+    evidenceRefs: Array.isArray(item.evidenceRefs) ? item.evidenceRefs : []
+  }));
+}
+function parseRoadmapPhases(arr) {
+  if (!Array.isArray(arr)) return [];
+  return arr.map((phase) => ({
+    title: phase.title ?? "",
+    priority: validatePriority(phase.priority),
+    goal: phase.goal ?? phase.description ?? "",
+    scope: toStringArray(phase.scope),
+    deliverables: toStringArray(phase.deliverables),
+    dependencies: toStringArray(phase.dependencies),
+    risks: toStringArray(phase.risks),
+    successCriteria: toStringArray(phase.successCriteria),
+    relatedFindings: toStringArray(phase.relatedFindings)
+  }));
+}
+function validatePriority(value) {
+  if (value === "high" || value === "medium" || value === "low") return value;
+  return "medium";
+}
+function toStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function formatClaimsForReview(claims) {
+  if (claims.length === 0) return "No claims to review.";
+  return claims.map((c) => {
+    const f = c.finding;
+    const evidence = c.evidenceRefs.length > 0 ? `
+    Evidence: ${c.evidenceRefs.join(", ")}` : "";
+    const packets = c.evidencePacketIds.length > 0 ? `
+    Evidence packets: ${c.evidencePacketIds.join(", ")}` : "";
+    return `- [${c.claimId}] (${f.kind}${f.severity ? `, ${f.severity}` : ""}, status: ${c.status})
+    ${sanitizeForPrompt(f.title)}
+    ${sanitizeForPrompt(f.summary)}` + evidence + packets + `
+    Confidence: ${f.confidence}`;
+  }).join("\n\n");
+}
+function formatDebateHistory(turns) {
+  if (turns.length === 0) return "No prior debate turns.";
+  return turns.map(
+    (t) => `[${t.participant}] stance: ${t.stance}
+  ${t.summary}` + (t.newEvidenceRefs?.length ? `
+  New evidence: ${t.newEvidenceRefs.join(", ")}` : "")
+  ).join("\n");
+}
+function formatClaimSummaryForConsensus(summary) {
+  const sections = [];
+  if (summary.verified.length > 0) {
+    sections.push(
+      `### Verified Claims (${summary.verified.length})
+` + summary.verified.map(
+        (c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} (${c.finding.kind}, confidence: ${c.finding.confidence})`
+      ).join("\n")
+    );
+  }
+  if (summary.unresolved.length > 0) {
+    sections.push(
+      `### Unresolved Claims (${summary.unresolved.length})
+` + summary.unresolved.map(
+        (c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} \u2014 ${c.challenges.length} challenge(s), no consensus reached`
+      ).join("\n")
+    );
+  }
+  if (summary.contested.length > 0) {
+    sections.push(
+      `### Still Contested (${summary.contested.length})
+` + summary.contested.map(
+        (c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} \u2014 ${c.challenges.length} challenge(s)`
+      ).join("\n")
+    );
+  }
+  if (summary.rejected.length > 0) {
+    sections.push(
+      `### Rejected Claims (${summary.rejected.length})
+` + summary.rejected.map(
+        (c) => `- [${c.claimId}] ${sanitizeForPrompt(c.finding.title)} \u2014 rejected: ${sanitizeForPrompt(c.adjudication?.rationale ?? "no rationale")}`
+      ).join("\n")
+    );
+  }
+  return sections.length > 0 ? sections.join("\n\n") : "No claims processed.";
+}
+function formatDigestForPrompt(digest) {
+  const sections = [];
+  sections.push(`Claims under review: ${digest.relevantClaimIds.join(", ")}`);
+  if (digest.evidencePackets.length > 0) {
+    sections.push("\nEvidence:");
+    for (const p of digest.evidencePackets) {
+      sections.push(`  [${p.packetId}] ${sanitizeForPrompt(p.title)} (${p.source}): ${sanitizeForPrompt(p.summary)}`);
+      for (const e of p.excerpts.slice(0, 2)) {
+        sections.push(`    > ${e.ref}: ${sanitizeForPrompt(e.snippet)}`);
+      }
+    }
+  }
+  if (digest.recentChallenges.length > 0) {
+    sections.push("\nPrior challenges:");
+    for (const c of digest.recentChallenges) {
+      sections.push(`  [${c.reviewer}] on ${c.claimId}: ${c.verdict} \u2014 ${sanitizeForPrompt(c.reason)}`);
+    }
+  }
+  return sections.join("\n");
+}
+function parseChallenges(reviewer, text) {
+  try {
+    const json = extractJSONArray(text);
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed)) {
+      const objJson = extractJSON(text);
+      const obj = JSON.parse(objJson);
+      if (Array.isArray(obj.challenges)) {
+        return obj.challenges.map((r) => parseChallenge(reviewer, r));
+      }
+      return [];
+    }
+    return parsed.map((r) => parseChallenge(reviewer, r));
+  } catch {
+    return [];
+  }
+}
+function parseChallenge(reviewer, raw) {
+  return {
+    reviewer,
+    claimId: asString(raw.claimId ?? raw.claim_id),
+    verdict: validateVerdict(raw.verdict),
+    reason: asString(raw.reason),
+    supportingEvidenceRefs: Array.isArray(raw.supportingEvidenceRefs) ? raw.supportingEvidenceRefs : void 0,
+    requestedChecks: Array.isArray(raw.requestedChecks) ? raw.requestedChecks.map((rc) => ({
+      requestId: rc.requestId ?? `req-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      claimId: raw.claimId ?? raw.claim_id ?? "",
+      requester: reviewer,
+      description: rc.description ?? "",
+      refs: Array.isArray(rc.refs) ? rc.refs : void 0,
+      priority: validateCheckPriority(rc.priority)
+    })) : void 0
+  };
+}
+function validateCheckPriority(v) {
+  if (v === "high" || v === "medium" || v === "low") return v;
+  return void 0;
+}
+function parseDebateTurn(participant, text) {
+  try {
+    const json = extractJSON(text);
+    const parsed = JSON.parse(json);
+    return {
+      participant,
+      stance: validateStance(parsed.stance),
+      summary: parsed.summary ?? parsed.argument ?? "",
+      newEvidenceRefs: Array.isArray(parsed.newEvidenceRefs) ? parsed.newEvidenceRefs : void 0
+    };
+  } catch {
+    return {
+      participant,
+      stance: "uncertain",
+      summary: text.slice(0, 1e3)
+    };
+  }
+}
+function validateStance(v) {
+  if (v === "support" || v === "oppose" || v === "narrow" || v === "uncertain") return v;
+  return "uncertain";
+}
+function parseAdjudication(claimId, text) {
+  try {
+    const json = extractJSON(text);
+    const parsed = JSON.parse(json);
+    return {
+      claimId,
+      outcome: validateAdjudicationOutcome(parsed.outcome),
+      rationale: asString(parsed.rationale),
+      finalSummary: asString(parsed.finalSummary ?? parsed.summary),
+      supportingEvidenceRefs: Array.isArray(parsed.supportingEvidenceRefs) ? parsed.supportingEvidenceRefs : []
+    };
+  } catch {
+    return {
+      claimId,
+      outcome: "unresolved",
+      rationale: "Failed to parse adjudication response",
+      finalSummary: text.slice(0, 500),
+      supportingEvidenceRefs: []
+    };
+  }
+}
+function validateAdjudicationOutcome(v) {
+  if (v === "accepted" || v === "accepted_with_revision" || v === "rejected" || v === "unresolved") return v;
+  return "unresolved";
+}
+function parseDetailExpansion(text) {
+  try {
+    const json = extractJSON(text);
+    const parsed = JSON.parse(json);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("parsed JSON is not an object");
+    }
+    return {
+      phaseTitle: asString(parsed.phaseTitle),
+      objective: asString(parsed.objective),
+      targetFiles: toStringArray(parsed.targetFiles),
+      codeChanges: toStringArray(parsed.codeChanges),
+      interfaces: toStringArray(parsed.interfaces),
+      migrationSteps: toStringArray(parsed.migrationSteps),
+      validation: toStringArray(parsed.validation),
+      effort: validateEffort(parsed.effort),
+      blockers: toStringArray(parsed.blockers),
+      evidenceRefs: toStringArray(parsed.evidenceRefs)
+    };
+  } catch {
+    return {
+      phaseTitle: "",
+      objective: text.slice(0, 500),
+      targetFiles: [],
+      codeChanges: [],
+      interfaces: [],
+      migrationSteps: [],
+      validation: [],
+      effort: "medium",
+      blockers: [],
+      evidenceRefs: []
+    };
+  }
+}
+function validateEffort(v) {
+  if (v === "small" || v === "medium" || v === "large") return v;
+  return "medium";
+}
+
+// src/arena/strategies/review.ts
+var ReviewStrategy = class {
+  // ─── Research Phase ──────────────────────────────────────────
+  researchSystemPrompt(name) {
+    return `You are ${name}, a reviewer in a multi-model review arena.
+
+You may have access to read-only tools to fetch additional context. The base context is intentionally lean \u2014 use tools to inspect details as needed.
+
+IMPORTANT RULES:
+- Limit yourself to 3-5 tool rounds. Do NOT exhaustively read every file.
+- Focus on the HIGHEST-IMPACT findings. Quality over quantity.
+- Output as many findings as the topic warrants \u2014 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.
+- Prioritize: risks > improvements > questions. Strengths are optional.
+
+When ready, respond ONLY with JSON (no markdown fences):
+{"contextSummary": "brief summary of what you investigated", "findings": [{"id": "unique-id", "kind": "risk|improvement|question|strength", "title": "short title", "summary": "detailed explanation", "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 `## Review Topic
+${topic}
+
+${formatBaseContext(baseContext)}
+
+Use tools to read specific files from the diff. Then output 3-6 highest-confidence findings as JSON.`;
+  }
+  parseResearchResponse(participant, text) {
+    return parseReport(participant, text);
+  }
+  // ─── Cross Review Phase ──────────────────────────────────────
+  crossReviewSystemPrompt(reviewerName) {
+    return `You are ${reviewerName}, reviewing other participants' review findings.
+
+For each finding, provide a verdict:
+- "agree": you confirm this finding
+- "refine": mostly agree but with refinements
+- "disagree": you believe this finding is incorrect
+- "needs_evidence": the finding lacks sufficient evidence
+
+Focus on HIGH VALUE findings: high severity, high risk, or conflicting conclusions.
+You don't need to review every single finding \u2014 prioritize the important ones.
+
+Respond ONLY with a JSON array (no markdown fences):
+[{"findingId": "...", "verdict": "agree|refine|disagree|needs_evidence", "reason": "...", "extraEvidence": ["optional"]}]`;
+  }
+  crossReviewUserPrompt(topic, myReport, otherReports) {
+    return `## Topic: ${topic}
+
+## Your Findings
+${formatReports([myReport])}
+
+## Other Reviewers' Findings
+${formatReports(otherReports)}
+
+Review the other participants' findings. Focus on high-priority items.`;
+  }
+  parseCrossReviewResponse(reviewer, text) {
+    return parseReviews(reviewer, text);
+  }
+  // ─── Consensus Phase ─────────────────────────────────────────
+  consensusSystemPrompt() {
+    return `You are a neutral moderator synthesizing a multi-model review into a structured consensus.
+
+You MUST faithfully reflect the aggregated findings and peer reviews. Do NOT add new conclusions that have no source in the findings.
+
+IMPORTANT: Start with a "subjectSummary" \u2014 a factual overview of WHAT is being reviewed (scope, key areas, high-level description). This comes BEFORE any judgment.
+
+Respond ONLY with JSON (no markdown fences):
+{
+  "summary": "one-paragraph overall assessment",
+  "subjectSummary": "factual overview of what is being reviewed \u2014 scope, key areas, subject description",
+  "strengths": [{"title": "...", "summary": "...", "support": ["participant names"], "challenge": [], "confidence": 0.0-1.0, "evidenceRefs": ["finding IDs"]}],
+  "improvements": [same structure],
+  "risks": [same structure],
+  "openQuestions": [same structure],
+  "nextActions": [{"title": "...", "priority": "high|medium|low", "rationale": "...", "relatedFindings": ["finding IDs"]}]
+}`;
+  }
+  consensusUserPrompt(topic, reports, reviews) {
+    return `## Topic
+${topic}
+
+## Participant Reports
+${formatReports(reports)}
+
+## Peer Reviews
+${formatFindingReviews(reviews)}
+
+Synthesize a structured consensus. Group findings by category, note agreement/disagreement, and propose next actions.`;
+  }
+  parseConsensusResponse(text) {
+    return parseConsensus(text);
+  }
+  preferredFindingKinds() {
+    return ["strength", "improvement", "risk", "question"];
+  }
+  // ─── V2: Verification Review ────────────────────────────────────
+  verificationReviewUserPrompt(topic, myReport, claimsToReview, digest) {
+    return `## Topic: ${topic}
+
+## Your Findings
+${formatReports([myReport])}
+
+## Claims to Verify
+${formatClaimsForReview(claimsToReview)}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+Verify each claim against the evidence. For claims lacking evidence, you may request specific checks.
+Respond ONLY with a JSON array:
+[{"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}
+
+## Contested Claim
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+Evidence: ${claim.evidenceRefs.join(", ") || "none"}
+
+## Prior Debate
+${formatDebateHistory(priorTurns)}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+State your position on this claim. Build on prior turns: cite specific evidence, acknowledge counter-arguments, and explain your reasoning in 150-300 words. Brevity here means missed nuance \u2014 depth wins.
+Respond ONLY with JSON:
+{"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}:
+${formatDebateHistory(r.participants)}
+${r.resolved ? "\u2192 Resolved" : "\u2192 Unresolved"}`
+    ).join("\n\n") : "No debate rounds occurred.";
+    return `## Topic: ${topic}
+
+## Claim Under Adjudication
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+Owner: ${claim.owner} | Status: ${claim.status}
+Evidence: ${claim.evidenceRefs.join(", ") || "none"}
+
+## Challenges
+` + claim.challenges.map((c) => `[${c.reviewer}] ${c.verdict}: ${c.reason}`).join("\n") + `
+
+## Debate
+${debateSummary}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+As moderator, adjudicate this claim based on all available evidence.
+Respond ONLY with JSON:
+{"outcome": "accepted|accepted_with_revision|rejected|unresolved", "rationale": "...", "finalSummary": "revised claim summary if needed", "supportingEvidenceRefs": ["..."]}`;
+  }
+  parseAdjudicationResponse(text) {
+    return parseAdjudication("", text);
+  }
+  // ─── V2: Claim-Aware Consensus ─────────────────────────────────
+  claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary) {
+    return `## Topic
+${topic}
+
+## Claim Verification Status
+${formatClaimSummaryForConsensus(claimSummary)}
+
+## Participant Reports
+${formatReports(reports)}
+
+## Peer Reviews
+${formatFindingReviews(reviews)}
+
+Synthesize a structured consensus. Verified claims should appear as high-confidence items. Unresolved claims should appear as open questions. Rejected claims should be excluded or noted as dismissed.`;
+  }
+};
+
+// src/arena/strategies/discussion.ts
+init_esm_shims();
+var DiscussionStrategy = class {
+  researchSystemPrompt(name) {
+    return `You are ${name}, participating in a multi-model discussion arena.
+
+You may have access to read-only tools to gather evidence. The base context is intentionally lean \u2014 use tools as needed.
+
+IMPORTANT RULES:
+- Limit yourself to 3-5 tool rounds. Do NOT exhaustively read every file.
+- Output as many findings as the topic warrants \u2014 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.
+- Focus on trade-offs, risks, and open questions. Strengths are optional.
+
+Respond ONLY with JSON (no markdown fences):
+{"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
+${topic}
+
+${formatBaseContext(baseContext)}
+
+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.
+
+Engage thoughtfully: challenge weak arguments, acknowledge strong ones.
+Focus on finding the best answer, not winning.
+
+For each finding you want to address, provide a verdict:
+- "agree": you confirm this perspective
+- "refine": mostly agree but with nuances
+- "disagree": you have a different view with evidence
+- "needs_evidence": the claim lacks supporting evidence
+
+Respond ONLY with a JSON array:
+[{"findingId": "...", "verdict": "...", "reason": "...", "extraEvidence": ["optional"]}]`;
+  }
+  crossReviewUserPrompt(topic, myReport, otherReports) {
+    return `## Topic: ${topic}
+
+## Your Analysis
+${formatReports([myReport])}
+
+## Other Participants' Analysis
+${formatReports(otherReports)}
+
+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.
+
+Capture key insights, agreements, and remaining disagreements. Do NOT suppress minority viewpoints \u2014 preserve them as open questions.
+
+IMPORTANT: Start with a "subjectSummary" \u2014 a factual framing of the topic, current scope, or assumptions under discussion before moving into conclusions.
+
+Respond ONLY with JSON (no markdown fences):
+{
+  "summary": "balanced synthesis",
+  "subjectSummary": "factual problem framing or current scope of the discussion",
+  "strengths": [{"title": "...", "summary": "...", "support": [], "challenge": [], "confidence": 0.0-1.0, "evidenceRefs": []}],
+  "improvements": [same structure],
+  "risks": [same structure],
+  "openQuestions": [same structure \u2014 include still-debated points],
+  "nextActions": [{"title": "...", "priority": "high|medium|low", "rationale": "...", "relatedFindings": []}]
+}`;
+  }
+  consensusUserPrompt(topic, reports, reviews) {
+    return `## Topic
+${topic}
+
+## Participant Analyses
+${formatReports(reports)}
+
+## Peer Reviews
+${formatFindingReviews(reviews)}
+
+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}
+
+## Your Analysis
+${formatReports([myReport])}
+
+## Claims to Verify
+${formatClaimsForReview(claimsToReview)}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+Engage critically with each claim. Challenge weak arguments, acknowledge strong ones. Focus on finding the best answer, not winning.
+Respond ONLY with a JSON array:
+[{"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}
+
+## Contested Claim
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+
+## Prior Debate
+${formatDebateHistory(priorTurns)}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+Engage thoughtfully. If the evidence supports the claim, narrow toward agreement. If not, explain why with evidence.
+Respond ONLY with JSON:
+{"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}:
+${formatDebateHistory(r.participants)}
+${r.resolved ? "\u2192 Resolved" : "\u2192 Unresolved"}`
+    ).join("\n\n") : "No debate rounds occurred.";
+    return `## Topic: ${topic}
+
+## Contested Claim
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+Owner: ${claim.owner}
+
+## Challenges
+` + claim.challenges.map((c) => `[${c.reviewer}] ${c.verdict}: ${c.reason}`).join("\n") + `
+
+## Debate
+${debateSummary}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+As moderator, synthesize the debate. Preserve minority viewpoints where the evidence is genuinely ambiguous.
+Respond ONLY with JSON:
+{"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
+${topic}
+
+## Claim Verification Status
+${formatClaimSummaryForConsensus(claimSummary)}
+
+## Participant Analyses
+${formatReports(reports)}
+
+## Peer Reviews
+${formatFindingReviews(reviews)}
+
+Synthesize a balanced conclusion. Verified claims are high-confidence. Unresolved claims should be preserved as open questions \u2014 do NOT suppress minority viewpoints.`;
+  }
+};
+
+// src/arena/strategies/planning.ts
+init_esm_shims();
+var PlanningStrategy = class {
+  researchSystemPrompt(name) {
+    return `You are ${name}, a planner in a multi-model planning session.
+
+You may have access to read-only tools to investigate the subject. The base context is intentionally lean \u2014 use tools as needed.
+
+IMPORTANT RULES:
+- Limit yourself to 3-5 tool rounds. Do NOT exhaustively read every file.
+- Output as many findings as the topic warrants \u2014 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.
+- Focus on: implementation phases (improvement), risks/blockers, decisions needed (question).
+- Strengths are optional.
+
+Respond ONLY with JSON (no markdown fences):
+{"contextSummary": "what you investigated and your overall approach", "findings": [{"id": "unique-id", "kind": "improvement|risk|question|strength", "title": "short title", "summary": "detailed analysis", "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 `## Planning Topic
+${topic}
+
+${formatBaseContext(baseContext)}
+
+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 architects' planning proposals.
+
+Evaluate critically: identify gaps, suggest improvements, propose better alternatives.
+
+For each finding you want to address:
+- "agree": the proposed phase/risk is valid
+- "refine": adjust scope, priority, or dependencies
+- "disagree": propose a different approach
+- "needs_evidence": more investigation needed
+
+Respond ONLY with a JSON array:
+[{"findingId": "...", "verdict": "...", "reason": "...", "extraEvidence": ["optional"]}]`;
+  }
+  crossReviewUserPrompt(topic, myReport, otherReports) {
+    return `## Topic: ${topic}
+
+## Your Proposed Plan
+${formatReports([myReport])}
+
+## Other Architects' Plans
+${formatReports(otherReports)}
+
+Review the other proposals. What are the strengths and gaps? Can elements be combined?`;
+  }
+  parseCrossReviewResponse(reviewer, text) {
+    return parseReviews(reviewer, text);
+  }
+  consensusSystemPrompt() {
+    return `You are a neutral moderator synthesizing a multi-model planning session into a concrete roadmap.
+
+Combine the best ideas into a unified plan with clear sequencing, priorities, and delivery phases.
+IMPORTANT: the roadmap field is the primary output. Use it to describe 3 to 6 implementation phases. The nextActions field is only for the immediate 3 to 5 actions that should happen next.
+
+Respond ONLY with JSON (no markdown fences):
+{
+  "summary": "unified plan overview",
+  "subjectSummary": "factual overview of the current repo/problem scope before proposing changes",
+  "strengths": [{"title": "...", "summary": "...", "support": [], "challenge": [], "confidence": 0.0-1.0, "evidenceRefs": []}],
+  "improvements": [implementation phases as consensus items],
+  "risks": [identified risks],
+  "openQuestions": [decisions needed],
+  "roadmap": [{"title": "...", "priority": "high|medium|low", "goal": "...", "scope": ["..."], "deliverables": ["..."], "dependencies": ["..."], "risks": ["..."], "successCriteria": ["..."], "relatedFindings": []}],
+  "nextActions": [{"title": "...", "priority": "high|medium|low", "rationale": "...", "relatedFindings": []}]
+}`;
+  }
+  consensusUserPrompt(topic, reports, reviews) {
+    return `## Topic
+${topic}
+
+## Proposed Plans
+${formatReports(reports)}
+
+## Peer Reviews
+${formatFindingReviews(reviews)}
+
+Synthesize a final implementation roadmap.
+Requirements:
+- Start with a factual subjectSummary of the current scope.
+- Produce 3 to 6 roadmap phases covering sequencing, dependencies, deliverables, and success criteria.
+- Use nextActions only for the immediate follow-up work, not the entire roadmap.`;
+  }
+  parseConsensusResponse(text) {
+    return parseConsensus(text);
+  }
+  preferredFindingKinds() {
+    return ["improvement", "risk", "question"];
+  }
+  // ─── V2: Verification Review ────────────────────────────────────
+  verificationReviewUserPrompt(topic, myReport, claimsToReview, digest) {
+    return `## Topic: ${topic}
+
+## Your Proposed Plan
+${formatReports([myReport])}
+
+## Claims to Verify
+${formatClaimsForReview(claimsToReview)}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+Evaluate each claim for feasibility, sequencing, and dependencies. Challenge proposals that lack evidence.
+Respond ONLY with a JSON array:
+[{"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}
+
+## Contested Planning Proposal
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+
+## Prior Debate
+${formatDebateHistory(priorTurns)}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+Argue for or against this proposal. Focus on feasibility, risks, and better alternatives.
+Respond ONLY with JSON:
+{"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}:
+${formatDebateHistory(r.participants)}
+${r.resolved ? "\u2192 Resolved" : "\u2192 Unresolved"}`
+    ).join("\n\n") : "No debate rounds occurred.";
+    return `## Topic: ${topic}
+
+## Contested Proposal
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+Owner: ${claim.owner}
+
+## Challenges
+` + claim.challenges.map((c) => `[${c.reviewer}] ${c.verdict}: ${c.reason}`).join("\n") + `
+
+## Debate
+${debateSummary}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+As moderator, decide whether this proposal should be included in the final plan.
+Respond ONLY with JSON:
+{"outcome": "accepted|accepted_with_revision|rejected|unresolved", "rationale": "...", "finalSummary": "revised proposal if needed", "supportingEvidenceRefs": ["..."]}`;
+  }
+  parseAdjudicationResponse(text) {
+    return parseAdjudication("", text);
+  }
+  // ─── Planning: Merge-Oriented Review ────────────────────────────
+  mergeReviewUserPrompt(topic, myReport, claimsToReview, digest) {
+    return `## Topic: ${topic}
+
+## Your Proposed Plan
+${formatReports([myReport])}
+
+## Candidate Claims (Proposed Phases & Findings)
+${formatClaimsForReview(claimsToReview)}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+You are reviewing planning proposals for MERGE and CONVERGENCE, not for correctness judging.
+
+For each claim, decide how it should be incorporated into the final roadmap:
+- "agree": the proposed phase/finding is valid as-is
+- "refine": merge with another phase, adjust priority/scope/dependencies, or narrow scope
+- "disagree": only for proposals that directly contradict repo evidence
+- "needs_evidence": mark as open question for further investigation
+
+In your reason, use these semantic tags where applicable:
+[merge] \u2014 combine with another phase
+[reprioritize] \u2014 change priority ordering
+[split_phase] \u2014 break into smaller phases
+[combine_phase] \u2014 merge multiple phases into one
+[dependency_risk] \u2014 flag missing dependency
+[needs_detail] \u2014 needs more implementation specifics
+[open_question] \u2014 convert to open question
+
+Respond ONLY with a JSON array:
+[{"claimId": "...", "verdict": "agree|refine|disagree|needs_evidence", "reason": "[tag] explanation", "supportingEvidenceRefs": ["optional"], "requestedChecks": [{"description": "what to check", "priority": "high|medium|low"}]}]`;
+  }
+  parseMergeReviewResponse(reviewer, text) {
+    return parseChallenges(reviewer, text);
+  }
+  // ─── Planning: Detail Expansion ────────────────────────────────
+  detailExpansionSystemPrompt() {
+    return `You are a senior architect expanding a high-level roadmap phase into a concrete, repo-level implementation plan.
+
+You may have access to read-only tools to investigate the codebase. Use them to verify file paths, interfaces, and module boundaries.
+
+IMPORTANT RULES:
+- Be specific: name actual files, modules, interfaces, and functions.
+- If you're uncertain about a target, write "likely: <path>" and note the uncertainty.
+- Do not produce vague platitudes like "refactor the module" \u2014 say what changes.
+- Limit tool usage to 2-3 rounds for verification.
+
+Respond ONLY with JSON (no markdown fences):
+{"phaseTitle": "...", "objective": "...", "targetFiles": ["..."], "codeChanges": ["specific change descriptions"], "interfaces": ["new or modified interfaces"], "migrationSteps": ["ordered steps"], "validation": ["how to verify"], "effort": "small|medium|large", "blockers": ["blocking issues"], "evidenceRefs": ["refs to supporting evidence"]}`;
+  }
+  detailExpansionUserPrompt(topic, phase, digest) {
+    const phaseContext = [
+      `Title: ${phase.title}`,
+      `Priority: ${phase.priority}`,
+      `Goal: ${phase.goal}`,
+      phase.scope.length > 0 ? `Scope: ${phase.scope.join("; ")}` : "",
+      phase.deliverables.length > 0 ? `Deliverables: ${phase.deliverables.join("; ")}` : "",
+      phase.dependencies.length > 0 ? `Dependencies: ${phase.dependencies.join("; ")}` : "",
+      phase.risks.length > 0 ? `Risks: ${phase.risks.join("; ")}` : "",
+      phase.successCriteria.length > 0 ? `Success Criteria: ${phase.successCriteria.join("; ")}` : "",
+      phase.relatedFindings.length > 0 ? `Related Findings: ${phase.relatedFindings.join(", ")}` : ""
+    ].filter(Boolean).join("\n");
+    return `## Overall Topic
+${topic}
+
+## Roadmap Phase to Expand
+${phaseContext}
+
+## Evidence Digest
+${formatDigestForPrompt(digest)}
+
+Expand this phase into a repo-level implementation plan.
+Use tools to verify file paths and interfaces if available.
+Answer these questions:
+1. Which files/modules need to change?
+2. What are the specific code changes?
+3. What interfaces need to be added or modified?
+4. What are the migration steps (in order)?
+5. How do we validate the changes?
+6. What is the effort estimate?
+7. What are the blockers?`;
+  }
+  parseDetailExpansionResponse(text) {
+    return parseDetailExpansion(text);
+  }
+  // ─── V2: Claim-Aware Consensus ─────────────────────────────────
+  claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary) {
+    return `## Topic
+${topic}
+
+## Claim Verification Status
+${formatClaimSummaryForConsensus(claimSummary)}
+
+## Proposed Plans
+${formatReports(reports)}
+
+## Peer Reviews
+${formatFindingReviews(reviews)}
+
+Synthesize a final implementation roadmap.
+Requirements:
+- Verified claims should form the backbone of the roadmap.
+- Unresolved claims should appear as open questions or conditional phases.
+- Produce 3 to 6 roadmap phases with sequencing, dependencies, deliverables, and success criteria.
+- Use nextActions only for immediate follow-up work.`;
+  }
+};
+
+// src/arena/lenses/index.ts
+init_esm_shims();
+
+// src/arena/lenses/engineering.ts
+init_esm_shims();
+var 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"]
+};
+
+// src/arena/lenses/product.ts
+init_esm_shims();
+var 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 \u2014 too broad or too narrow",
+    "User journey coherence",
+    "Metric and success criteria definition",
+    "Stakeholder alignment"
+  ],
+  preferredFindingKinds: ["question", "improvement", "risk", "strength"]
+};
+
+// src/arena/lenses/architecture.ts
+init_esm_shims();
+var 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"]
+};
+
+// src/arena/lenses/general.ts
+init_esm_shims();
+var 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"]
+};
+
+// src/arena/lenses/index.ts
+var LENS_MAP = {
+  engineering: engineeringLens,
+  product: productLens,
+  architecture: architectureLens,
+  general: generalLens
+};
+function getLens(name) {
+  return LENS_MAP[name];
+}
+function resolveLenses(refs) {
+  return refs.map((ref) => LENS_MAP[ref.name]);
+}
+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");
+}
+var LENS_NAMES = ["engineering", "product", "architecture", "general"];
+
+// src/arena/strategies/index.ts
+init_esm_shims();
+
+// src/arena/strategies/lens-wrapper.ts
+init_esm_shims();
+function withLens(strategy, plan) {
+  const lenses = resolveLenses(plan.lenses);
+  if (lenses.length === 0) return strategy;
+  const participantLensPrompt = buildLensPrompt(lenses, "participant");
+  const reviewerLensPrompt = buildLensPrompt(lenses, "reviewer");
+  const moderatorLensPrompt = buildLensPrompt(lenses, "moderator");
+  const participantPlanPrompt = buildPlanPrompt(plan, "participant");
+  const reviewerPlanPrompt = buildPlanPrompt(plan, "reviewer");
+  const moderatorPlanPrompt = buildPlanPrompt(plan, "moderator");
+  return {
+    researchSystemPrompt(name) {
+      return [
+        strategy.researchSystemPrompt(name),
+        "",
+        "\u2500\u2500 Analysis Perspective \u2500\u2500",
+        participantLensPrompt,
+        "",
+        "\u2500\u2500 Scenario Support \u2500\u2500",
+        participantPlanPrompt
+      ].join("\n");
+    },
+    researchUserPrompt(topic, ctx) {
+      return [formatPlanBrief(plan), "", strategy.researchUserPrompt(topic, ctx)].join("\n");
+    },
+    parseResearchResponse(participant, text) {
+      return strategy.parseResearchResponse(participant, text);
+    },
+    crossReviewSystemPrompt(reviewerName) {
+      return [
+        strategy.crossReviewSystemPrompt(reviewerName),
+        "",
+        "\u2500\u2500 Review Perspective \u2500\u2500",
+        reviewerLensPrompt,
+        "",
+        "\u2500\u2500 Scenario Support \u2500\u2500",
+        reviewerPlanPrompt
+      ].join("\n");
+    },
+    crossReviewUserPrompt(topic, my, others) {
+      return [formatPlanBrief(plan), "", strategy.crossReviewUserPrompt(topic, my, others)].join("\n");
+    },
+    parseCrossReviewResponse(reviewer, text) {
+      return strategy.parseCrossReviewResponse(reviewer, text);
+    },
+    consensusSystemPrompt() {
+      return [
+        strategy.consensusSystemPrompt(),
+        "",
+        "\u2500\u2500 Moderator Perspective \u2500\u2500",
+        moderatorLensPrompt,
+        "",
+        "\u2500\u2500 Scenario Support \u2500\u2500",
+        moderatorPlanPrompt
+      ].join("\n");
+    },
+    consensusUserPrompt(topic, reports, reviews) {
+      return [formatPlanBrief(plan), "", strategy.consensusUserPrompt(topic, reports, reviews)].join("\n");
+    },
+    parseConsensusResponse(text) {
+      return strategy.parseConsensusResponse(text);
+    },
+    preferredFindingKinds() {
+      const modeKinds = strategy.preferredFindingKinds();
+      const lensKinds = lenses.flatMap((l) => l.preferredFindingKinds);
+      const planKinds = plan.outputShape.emphasize;
+      const seen = /* @__PURE__ */ new Set();
+      const result = [];
+      for (const k of [...planKinds, ...modeKinds, ...lensKinds]) {
+        if (!seen.has(k)) {
+          seen.add(k);
+          result.push(k);
+        }
+      }
+      return result;
+    },
+    // ─── V2 forwarding (conditional) ─────────────────────────────
+    ...isStrategyV2(strategy) ? {
+      verificationReviewUserPrompt(topic, myReport, claims, digest) {
+        return [formatPlanBrief(plan), "", strategy.verificationReviewUserPrompt(topic, myReport, claims, digest)].join("\n");
+      },
+      parseVerificationReviewResponse(reviewer, text) {
+        return strategy.parseVerificationReviewResponse(reviewer, text);
+      },
+      debateTurnUserPrompt(topic, claim, priorTurns, digest) {
+        return [formatPlanBrief(plan), "", strategy.debateTurnUserPrompt(topic, claim, priorTurns, digest)].join("\n");
+      },
+      parseDebateTurnResponse(participant, text) {
+        return strategy.parseDebateTurnResponse(participant, text);
+      },
+      adjudicationUserPrompt(topic, claim, rounds, digest) {
+        return [formatPlanBrief(plan), "", strategy.adjudicationUserPrompt(topic, claim, rounds, digest)].join("\n");
+      },
+      parseAdjudicationResponse(text) {
+        return strategy.parseAdjudicationResponse(text);
+      },
+      claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary) {
+        return [formatPlanBrief(plan), "", strategy.claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary)].join("\n");
+      }
+    } : {},
+    // ─── Planning forwarding (conditional) ──────────────────────
+    ...isStrategyPlanning(strategy) ? {
+      mergeReviewUserPrompt(topic, myReport, claims, digest) {
+        return [formatPlanBrief(plan), "", strategy.mergeReviewUserPrompt(topic, myReport, claims, digest)].join("\n");
+      },
+      parseMergeReviewResponse(reviewer, text) {
+        return strategy.parseMergeReviewResponse(reviewer, text);
+      },
+      detailExpansionSystemPrompt() {
+        return [
+          strategy.detailExpansionSystemPrompt(),
+          "",
+          "\u2500\u2500 Moderator Perspective \u2500\u2500",
+          moderatorLensPrompt
+        ].join("\n");
+      },
+      detailExpansionUserPrompt(topic, phase, digest) {
+        return [formatPlanBrief(plan), "", strategy.detailExpansionUserPrompt(topic, phase, digest)].join("\n");
+      },
+      parseDetailExpansionResponse(text) {
+        return strategy.parseDetailExpansionResponse(text);
+      }
+    } : {}
+  };
+}
+function buildPlanPrompt(plan, phase) {
+  const sources = plan.sources.map((s) => s.kind).join(", ");
+  const targets = formatTargets(plan.subject.targets);
+  const emphasis = formatEmphasis(plan.outputShape.emphasize);
+  const notes = [
+    `Subject: ${plan.subject.kind} \u2014 ${plan.subject.label}${targets ? ` (${targets})` : ""}`,
+    `Evidence sources: ${sources || "none"}`,
+    `Overview label: ${plan.outputShape.overviewLabel}`,
+    `Emphasize these finding types first: ${emphasis}`,
+    "Only draw conclusions from available evidence. When evidence is thin, narrow the claim or call it out explicitly.",
+    ...buildScenarioNotes(plan, phase)
+  ];
+  return notes.map((line) => `- ${line}`).join("\n");
+}
+function formatPlanBrief(plan) {
+  const targets = formatTargets(plan.subject.targets);
+  const lenses = plan.lenses.map((l) => l.name).join(", ");
+  const sources = plan.sources.map((s) => s.kind).join(", ");
+  return [
+    "## Arena Plan",
+    `- Mode: ${plan.mode}`,
+    `- Subject: ${plan.subject.kind} \u2014 ${plan.subject.label}${targets ? ` (${targets})` : ""}`,
+    `- Lenses: ${lenses || "general"}`,
+    `- Sources: ${sources || "none"}`,
+    `- Output focus: ${formatEmphasis(plan.outputShape.emphasize)}`,
+    `- Overview label: ${plan.outputShape.overviewLabel}`
+  ].join("\n");
+}
+function buildScenarioNotes(plan, phase) {
+  const notes = [];
+  switch (plan.subject.kind) {
+    case "changes":
+      notes.push(
+        phase === "participant" ? "Treat this as a change-focused analysis: inspect behavioral impact, regressions, interfaces, and compatibility." : phase === "reviewer" ? "Challenge findings that are not grounded in changed behavior, affected files, or nearby code paths." : "Summarize the concrete impact of the changes before giving judgment."
+      );
+      break;
+    case "files":
+      notes.push(
+        phase === "participant" ? "Stay anchored to the named files/modules and their immediate call sites instead of drifting into unrelated areas." : phase === "reviewer" ? "Prioritize corrections to claims that overgeneralize beyond the named files/modules." : "Keep the conclusion scoped to the named files/modules and their direct implications."
+      );
+      break;
+    case "docs":
+      notes.push(
+        phase === "participant" ? "Treat this as a document-centric scene: look for ambiguity, missing acceptance criteria, edge cases, and implementation gaps." : phase === "reviewer" ? "Challenge findings that skip over unclear requirements, contradictory wording, or unsupported feasibility assumptions." : "Synthesize the document review around completeness, feasibility, and decision-ready gaps."
+      );
+      break;
+    case "topic":
+      notes.push(
+        phase === "participant" ? "Treat this as a topic discussion: surface assumptions, trade-offs, and decision criteria instead of pretending there is hard repo evidence." : phase === "reviewer" ? "Push back on overconfident claims and preserve unresolved trade-offs as open questions." : "Preserve disagreement where needed and make assumptions explicit."
+      );
+      break;
+    case "mixed":
+      notes.push(
+        phase === "participant" ? "This is a mixed scene: reconcile code, docs, and topic-level evidence instead of analyzing each source in isolation." : phase === "reviewer" ? "Check whether claims actually connect the different evidence sources, rather than citing only one side." : "Unify the conclusion across repo facts, documents, and higher-level reasoning."
+      );
+      break;
+  }
+  const sourceKinds = new Set(plan.sources.map((s) => s.kind));
+  if (sourceKinds.has("docs") && sourceKinds.has("repo")) {
+    notes.push(
+      phase === "moderator" ? "If documents and repo evidence diverge, call out the mismatch explicitly instead of collapsing it into a single conclusion." : "Cross-check document claims against the current repo structure when possible."
+    );
+  } else if (sourceKinds.has("web")) {
+    notes.push(
+      phase === "moderator" ? "Separate external references from local repo facts in the synthesis." : "Keep external research distinct from local evidence and label it clearly."
+    );
+  } else if (sourceKinds.has("none")) {
+    notes.push("No external evidence is expected here; reason from the prompt and make assumptions visible.");
+  }
+  if (plan.mode === "planning") {
+    notes.push(
+      phase === "moderator" ? "When enough evidence exists, turn the conclusion into a staged roadmap with sequencing, dependencies, and success criteria." : "Prefer findings that help phase work, sequence dependencies, or expose migration/blocker risks."
+    );
+  }
+  return notes;
+}
+function formatEmphasis(kinds) {
+  return kinds.length > 0 ? kinds.join(", ") : "risk, improvement";
+}
+function formatTargets(targets) {
+  return Array.isArray(targets) && targets.length > 0 ? targets.join(", ") : "";
+}
+
+// src/arena/strategies/index.ts
+var STRATEGY_MAP = {
+  review: () => new ReviewStrategy(),
+  discussion: () => new DiscussionStrategy(),
+  planning: () => new PlanningStrategy()
+};
+function getStrategy(mode) {
+  return STRATEGY_MAP[mode]();
+}
+function getStrategyForPlan(plan) {
+  const base = STRATEGY_MAP[plan.mode]();
+  return withLens(base, plan);
+}
+
+// src/arena/planner.ts
+init_esm_shims();
+var PLANNER_SYSTEM_PROMPT = `You are the planner for a multi-model collaborative analysis tool called Arena.
+
+Given a user's natural language request, produce an execution plan. You must determine:
+
+1. **mode** \u2014 how to collaborate:
+   - "review": find issues, verify quality, give a structured verdict
+   - "discussion": explore trade-offs, compare viewpoints, preserve disagreements
+   - "planning": build a roadmap, identify phases, dependencies, and risks
+
+2. **lenses** \u2014 from what analytical perspectives (can be multiple):
+   - "engineering": code quality, correctness, performance, maintainability
+   - "product": user value, requirements completeness, acceptance criteria, UX
+   - "architecture": system boundaries, modularity, coupling, evolution paths
+   - "general": broad analysis, logic, trade-offs (use as fallback)
+
+3. **sources** \u2014 where to gather evidence (can be multiple):
+   - "git": diffs, commit history, branch comparison, changed files
+   - "repo": directory structure, source code files, symbol search
+   - "docs": markdown/text documents, PRDs, design docs
+   - "web": external information, standards, competitor analysis
+   - "none": pure topic discussion, no external evidence needed
+
+4. **subject** \u2014 what is being analyzed:
+   - kind: "changes" (code changes), "files" (specific files), "docs" (documents), "topic" (abstract topic), "mixed"
+   - label: human-readable description
+   - targets: specific file paths, branch names, or doc names if applicable
+
+5. **outputShape** \u2014 what to emphasize in the output
+
+Respond ONLY with JSON, no markdown fences:
+{
+  "mode": "review|discussion|planning",
+  "lenses": [{"name": "engineering|product|architecture|general", "weight": 1.0}],
+  "sources": [{"kind": "git|repo|docs|web|none", "targets": ["optional specific targets"]}],
+  "subject": {"kind": "changes|files|docs|topic|mixed", "label": "description", "targets": ["optional"]},
+  "outputShape": {"overviewLabel": "e.g. What Changed / Current Scope / Problem Framing", "emphasize": ["risk", "improvement"]},
+  "confidence": "high|medium|low",
+  "followUpQuestion": "question if confidence is low, or null"
+}`;
+async function planArena(topic, llmConfig, flags, signal) {
+  if (flags?.mode && flags?.base) {
+    return buildExplicitPlan(topic, flags);
+  }
+  try {
+    signal?.throwIfAborted();
+    const client = await createLLMClient({
+      ...llmConfig,
+      enableStreaming: false,
+      maxTokens: 1024
+    });
+    const response = await client.createMessage({
+      systemPrompt: PLANNER_SYSTEM_PROMPT,
+      messages: [{ role: "user", content: `<user_request>
+${topic}
+</user_request>
+
+Analyze the user request above and output the arena plan as JSON.` }],
+      maxTokens: 1024,
+      signal
+    });
+    const plan = parsePlanResponse(response.text, topic);
+    if (flags?.mode) plan.mode = flags.mode;
+    if (flags?.base) {
+      plan.sources = [{ kind: "git", targets: [flags.base, flags.head ?? "HEAD"] }];
+      plan.subject = { kind: "changes", label: `${flags.base}...${flags.head ?? "HEAD"}`, targets: [flags.base, flags.head ?? "HEAD"] };
+    }
+    logger.info("arena.planner", { plan });
+    return plan;
+  } catch (err) {
+    logger.warn("arena.planner_fallback", { error: err.message });
+    return buildFallbackPlan(topic, flags);
+  }
+}
+function parsePlanResponse(text, topic) {
+  const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  const jsonStr = fenced ? fenced[1].trim() : text.match(/\{[\s\S]*\}/)?.[0] ?? text;
+  try {
+    const parsed = JSON.parse(jsonStr);
+    return {
+      mode: validateMode(parsed.mode),
+      lenses: parseLenses(parsed.lenses),
+      sources: parseSources(parsed.sources),
+      subject: parseSubject(parsed.subject, topic),
+      outputShape: parseOutputShape(parsed.outputShape, parsed.mode),
+      confidence: validateConfidence(parsed.confidence),
+      followUpQuestion: parsed.followUpQuestion || void 0
+    };
+  } catch {
+    return buildFallbackPlan(topic);
+  }
+}
+function buildExplicitPlan(topic, flags) {
+  return {
+    mode: flags.mode,
+    lenses: [{ name: "engineering", weight: 1 }],
+    sources: [
+      { kind: "git", targets: [flags.base, flags.head ?? "HEAD"] },
+      { kind: "repo" }
+    ],
+    subject: {
+      kind: "changes",
+      label: `${flags.base}...${flags.head ?? "HEAD"}`,
+      targets: [flags.base, flags.head ?? "HEAD"]
+    },
+    outputShape: {
+      overviewLabel: "What Changed",
+      emphasize: ["risk", "improvement"]
+    },
+    confidence: "high"
+  };
+}
+function buildFallbackPlan(topic, flags) {
+  if (flags?.base) {
+    return {
+      mode: flags.mode ?? "review",
+      lenses: [{ name: "engineering", weight: 1 }],
+      sources: [{ kind: "git" }, { kind: "repo" }],
+      subject: { kind: "changes", label: topic, targets: [flags.base, flags.head ?? "HEAD"] },
+      outputShape: {
+        overviewLabel: "What Changed",
+        emphasize: ["risk", "improvement"]
+      },
+      confidence: "low"
+    };
+  }
+  const lower = topic.toLowerCase();
+  const hasDoc = /\b(prd|doc|docs|spec|rfc|design doc|requirement|proposal)\b/i.test(topic) || /(文档|需求|方案)/.test(topic);
+  const hasRoadmap = /\b(roadmap|plan|planning|strategy|migration|refactor)\b/i.test(topic) || /(演进|路线图|规划|重构)/.test(topic);
+  const hasFeasibility = /\b(feasibility|feasible|can we|should we|trade-?off)\b/i.test(topic) || /(可行|能不能|值不值得|取舍)/.test(topic);
+  const hasReview = /\b(review|pr|diff|patch|change)\b/i.test(topic) || /(改动|评审|审查)/.test(topic);
+  const hasRepo = /\b(repo|repository|codebase|module|architecture)\b/i.test(topic) || /(代码库|仓库|模块|架构)/.test(topic);
+  if (hasRoadmap) {
+    return {
+      mode: "planning",
+      lenses: hasDoc ? [{ name: "architecture", weight: 1 }, { name: "product", weight: 0.7 }] : [{ name: "architecture", weight: 1 }, { name: "engineering", weight: 0.8 }],
+      sources: hasDoc ? [{ kind: "docs" }, ...hasRepo ? [{ kind: "repo" }] : []] : [{ kind: "repo" }, { kind: "docs" }],
+      subject: { kind: hasDoc ? "mixed" : "topic", label: topic },
+      outputShape: {
+        overviewLabel: "Current Scope",
+        emphasize: ["improvement", "risk", "question"]
+      },
+      confidence: "low"
+    };
+  }
+  if (hasDoc && hasFeasibility) {
+    return {
+      mode: "discussion",
+      lenses: [{ name: "product", weight: 1 }, { name: "engineering", weight: 0.8 }],
+      sources: hasRepo ? [{ kind: "docs" }, { kind: "repo" }] : [{ kind: "docs" }],
+      subject: { kind: hasRepo ? "mixed" : "docs", label: topic },
+      outputShape: {
+        overviewLabel: "Problem Framing",
+        emphasize: ["question", "risk", "improvement"]
+      },
+      confidence: "low"
+    };
+  }
+  if (hasDoc) {
+    return {
+      mode: hasReview ? "review" : "discussion",
+      lenses: [{ name: "product", weight: 1 }, { name: "architecture", weight: 0.6 }],
+      sources: hasRepo ? [{ kind: "docs" }, { kind: "repo" }] : [{ kind: "docs" }],
+      subject: { kind: hasRepo ? "mixed" : "docs", label: topic },
+      outputShape: {
+        overviewLabel: hasReview ? "Current Scope" : "Problem Framing",
+        emphasize: ["question", "improvement", "risk"]
+      },
+      confidence: "low"
+    };
+  }
+  if (hasFeasibility) {
+    return {
+      mode: "discussion",
+      lenses: hasRepo ? [{ name: "product", weight: 1 }, { name: "engineering", weight: 0.8 }] : [{ name: "general", weight: 1 }, { name: "product", weight: 0.6 }],
+      sources: hasRepo ? [{ kind: "repo" }, { kind: "docs" }] : [{ kind: "none" }],
+      subject: { kind: hasRepo ? "topic" : "topic", label: topic },
+      outputShape: {
+        overviewLabel: "Problem Framing",
+        emphasize: ["question", "risk", "improvement"]
+      },
+      confidence: "low"
+    };
+  }
+  if (hasReview || /\b(commit|branch|diff|patch|bug|fix|回归)\b/i.test(lower)) {
+    return {
+      mode: "review",
+      lenses: [{ name: "engineering", weight: 1 }],
+      sources: [{ kind: "git" }, { kind: "repo" }],
+      subject: { kind: "changes", label: topic },
+      outputShape: {
+        overviewLabel: "What Changed",
+        emphasize: ["risk", "improvement", "question"]
+      },
+      confidence: "low"
+    };
+  }
+  return {
+    mode: flags?.mode ?? "review",
+    lenses: [{ name: hasRepo ? "architecture" : "general", weight: 1 }],
+    sources: hasRepo ? [{ kind: "repo" }, { kind: "docs" }] : [{ kind: "none" }],
+    subject: { kind: "topic", label: topic },
+    outputShape: {
+      overviewLabel: hasRepo ? "Current Scope" : "Problem Framing",
+      emphasize: hasRepo ? ["improvement", "risk", "question"] : ["question", "risk", "improvement"]
+    },
+    confidence: "low"
+  };
+}
+function validateMode(v) {
+  if (v === "review" || v === "discussion" || v === "planning") return v;
+  return "review";
+}
+function validateConfidence(v) {
+  if (v === "high" || v === "medium" || v === "low") return v;
+  return "medium";
+}
+function parseLenses(v) {
+  if (!Array.isArray(v) || v.length === 0) {
+    return [{ name: "general", weight: 1 }];
+  }
+  const result = v.filter((item) => LENS_NAMES.includes(item?.name)).map((item) => ({
+    name: item.name,
+    weight: typeof item.weight === "number" ? item.weight : 1
+  }));
+  return result.length > 0 ? result : [{ name: "general", weight: 1 }];
+}
+function parseSources(v) {
+  if (!Array.isArray(v) || v.length === 0) {
+    return [{ kind: "none" }];
+  }
+  const validKinds = ["git", "repo", "docs", "web", "none"];
+  const result = v.filter((item) => validKinds.includes(item?.kind)).map((item) => ({
+    kind: item.kind,
+    targets: Array.isArray(item.targets) ? item.targets : void 0
+  }));
+  return result.length > 0 ? result : [{ kind: "none" }];
+}
+function parseSubject(v, topic) {
+  if (!v || typeof v !== "object") {
+    return { kind: "topic", label: topic };
+  }
+  const obj = v;
+  const validKinds = ["changes", "files", "docs", "topic", "mixed"];
+  return {
+    kind: validKinds.includes(obj.kind) ? obj.kind : "topic",
+    label: obj.label ?? topic,
+    targets: Array.isArray(obj.targets) ? obj.targets : void 0
+  };
+}
+var VALID_EMPHASIZE = /* @__PURE__ */ new Set(["strength", "improvement", "risk", "question"]);
+function parseOutputShape(v, mode) {
+  if (v && typeof v === "object") {
+    const obj = v;
+    return {
+      overviewLabel: obj.overviewLabel ?? "Overview",
+      emphasize: Array.isArray(obj.emphasize) ? obj.emphasize.filter((k) => VALID_EMPHASIZE.has(k)) : ["risk", "improvement"]
+    };
+  }
+  switch (mode) {
+    case "review":
+      return { overviewLabel: "What Changed", emphasize: ["risk", "improvement"] };
+    case "discussion":
+      return { overviewLabel: "Problem Framing", emphasize: ["strength", "risk", "question"] };
+    case "planning":
+      return { overviewLabel: "Current Scope", emphasize: ["improvement", "risk"] };
+    default:
+      return { overviewLabel: "Overview", emphasize: ["risk", "improvement"] };
+  }
+}
+
+// src/arena/providers/index.ts
+init_esm_shims();
+
+// src/arena/providers/git.ts
+init_esm_shims();
+import { execFileSync } from "child_process";
+var MAX_DIFF_CHARS = 2e4;
+var MAX_CHANGED_FILES = 30;
+var gitProvider = {
+  kind: "git",
+  collect(plan, _topic) {
+    const artifacts = [];
+    const targets = plan.sources.find((s) => s.kind === "git")?.targets;
+    const baseRef = sanitizeRef(targets?.[0]);
+    const headRef = sanitizeRef(targets?.[1]) ?? "HEAD";
+    const isCompare = !!baseRef;
+    const currentBranch = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (currentBranch) {
+      artifacts.push({
+        id: "git-branch",
+        kind: "doc",
+        source: "git",
+        title: "Current Branch",
+        preview: currentBranch
+      });
+    }
+    const logArgs = isCompare ? ["log", "--oneline", `${baseRef}..${headRef}`, "--max-count=20"] : ["log", "--oneline", "-10"];
+    const log = git(logArgs);
+    if (log) {
+      artifacts.push({
+        id: "git-log",
+        kind: "doc",
+        source: "git",
+        title: "Commit Log",
+        preview: log
+      });
+    }
+    const statArgs = isCompare ? ["diff", "--stat", `${baseRef}...${headRef}`] : ["diff", "--stat", "HEAD"];
+    let stat = git(statArgs);
+    if (!stat && !isCompare) stat = git(["diff", "--stat", "--cached"]);
+    if (stat) {
+      artifacts.push({
+        id: "git-diffstat",
+        kind: "doc",
+        source: "git",
+        title: "Diff Stat",
+        preview: stat
+      });
+    }
+    const filesArgs = isCompare ? ["diff", "--name-status", `${baseRef}...${headRef}`] : ["diff", "--name-status", "HEAD"];
+    let changedFiles = git(filesArgs);
+    if (!changedFiles && !isCompare) changedFiles = git(["diff", "--name-status", "--cached"]);
+    if (changedFiles) {
+      const allChanged = changedFiles.split("\n").filter(Boolean);
+      const limited = allChanged.slice(0, MAX_CHANGED_FILES);
+      if (allChanged.length > MAX_CHANGED_FILES) {
+        limited.push(`... and ${allChanged.length - MAX_CHANGED_FILES} more files`);
+      }
+      artifacts.push({
+        id: "git-changed-files",
+        kind: "doc",
+        source: "git",
+        title: "Changed Files",
+        preview: limited.join("\n"),
+        metadata: { totalCount: allChanged.length }
+      });
+      const paths = allChanged.map((line) => line.split("	").slice(1).join("	")).filter(Boolean);
+      const dirCounts = clusterByDirectory(paths);
+      if (dirCounts.length > 0) {
+        artifacts.push({
+          id: "git-dir-clusters",
+          kind: "doc",
+          source: "git",
+          title: "Changes by Directory",
+          preview: dirCounts.slice(0, 15).map(([dir, count]) => `  ${dir}/ (${count} files)`).join("\n")
+        });
+      }
+    }
+    const diffArgs = isCompare ? ["diff", `${baseRef}...${headRef}`] : ["diff", "HEAD"];
+    let diff = git(diffArgs);
+    if (!diff && !isCompare) diff = git(["diff", "--cached"]);
+    if (diff) {
+      const truncated = diff.length > MAX_DIFF_CHARS;
+      const preview = truncated ? diff.slice(0, MAX_DIFF_CHARS).slice(0, diff.slice(0, MAX_DIFF_CHARS).lastIndexOf("\n")) : diff;
+      artifacts.push({
+        id: "git-diff",
+        kind: "diff",
+        source: "git",
+        title: "Diff",
+        preview: preview + (truncated ? `
+
+... TRUNCATED (${diff.length} chars total). Use read_file to inspect specific files.` : ""),
+        metadata: { totalChars: diff.length, truncated }
+      });
+    }
+    if (!diff && !stat) {
+      const status = git(["status", "--short"]);
+      if (status) {
+        artifacts.push({
+          id: "git-status",
+          kind: "doc",
+          source: "git",
+          title: "Git Status",
+          preview: status
+        });
+      }
+    }
+    logger.info("arena.provider.git", {
+      artifactCount: artifacts.length,
+      hasCompare: isCompare
+    });
+    return artifacts;
+  }
+};
+function git(args) {
+  try {
+    return execFileSync("git", args, {
+      encoding: "utf-8",
+      maxBuffer: 1024 * 1024,
+      timeout: 1e4
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function sanitizeRef(ref) {
+  if (!ref) return void 0;
+  let cleaned = ref.replace(/\.{2,}/g, "");
+  cleaned = cleaned.replace(/[^a-zA-Z0-9/_\-~^.]/g, "");
+  return cleaned || void 0;
+}
+function clusterByDirectory(paths) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const parts = p.split("/");
+    const dir = parts.length > 2 ? parts.slice(0, 2).join("/") : parts[0];
+    counts.set(dir, (counts.get(dir) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1]);
+}
+
+// src/arena/providers/repo.ts
+init_esm_shims();
+import { existsSync, readdirSync, statSync, readFileSync } from "fs";
+import { join } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+var MAX_FILE_CHARS = 8e3;
+var repoProvider = {
+  kind: "repo",
+  collect(plan, topic) {
+    const artifacts = [];
+    const targets = plan.sources.find((s) => s.kind === "repo")?.targets ?? [];
+    const tree = buildTree(".", 2);
+    if (tree) {
+      artifacts.push({
+        id: "repo-tree",
+        kind: "tree",
+        source: "repo",
+        title: "Project Structure",
+        preview: tree
+      });
+    }
+    for (const target of targets) {
+      if (!existsSync(target)) continue;
+      const st = statSync(target);
+      if (st.isDirectory()) {
+        const dirTree = buildTree(target, 3);
+        if (dirTree) {
+          artifacts.push({
+            id: `repo-tree-${target}`,
+            kind: "tree",
+            source: "repo",
+            title: `Directory: ${target}`,
+            preview: dirTree
+          });
+        }
+        for (const file of collectEntryFiles(target).slice(0, 3)) {
+          const content = safeReadFile(file);
+          if (content) {
+            artifacts.push({
+              id: `repo-file-${file}`,
+              kind: "file",
+              source: "repo",
+              title: file,
+              ref: file,
+              preview: truncate(content)
+            });
+          }
+        }
+      } else {
+        const content = safeReadFile(target);
+        if (content) {
+          artifacts.push({
+            id: `repo-file-${target}`,
+            kind: "file",
+            source: "repo",
+            title: target,
+            ref: target,
+            preview: truncate(content)
+          });
+        }
+      }
+    }
+    if (targets.length === 0) {
+      const hints = extractSearchHints(topic);
+      for (const hint of hints.slice(0, 5)) {
+        const grepResult = safeGrep(hint);
+        if (grepResult) {
+          const files = grepResult.split("\n").filter(Boolean).slice(0, 10);
+          for (const file of files) {
+            if (!artifacts.some((a) => a.ref === file)) {
+              artifacts.push({
+                id: `repo-grep-${hint}-${file}`,
+                kind: "grep",
+                source: "repo",
+                title: `Match: ${hint} \u2192 ${file}`,
+                ref: file,
+                preview: file
+              });
+            }
+          }
+        }
+      }
+    }
+    const hasGitSource = plan.sources.some((s) => s.kind === "git");
+    if (!hasGitSource) {
+      const recentLog = gitLog();
+      if (recentLog) {
+        artifacts.push({
+          id: "repo-recent-activity",
+          kind: "doc",
+          source: "repo",
+          title: "Recent Git Activity",
+          preview: recentLog
+        });
+      }
+    }
+    logger.info("arena.provider.repo", { artifactCount: artifacts.length });
+    return artifacts;
+  }
+};
+function buildTree(dir, maxDepth, depth = 0, prefix = "") {
+  if (depth >= maxDepth) return "";
+  try {
+    const entries = readdirSync(dir).filter(
+      (e) => !e.startsWith(".") && e !== "node_modules" && e !== "dist" && e !== "__pycache__"
+    );
+    const lines = [];
+    for (const entry of entries.slice(0, 30)) {
+      const fullPath = join(dir, entry);
+      const isDir = statSync(fullPath).isDirectory();
+      lines.push(`${prefix}${isDir ? "/" : ""} ${entry}`);
+      if (isDir && depth < maxDepth - 1) {
+        lines.push(buildTree(fullPath, maxDepth, depth + 1, prefix + "  "));
+      }
+    }
+    return lines.filter(Boolean).join("\n");
+  } catch {
+    return "";
+  }
+}
+function collectEntryFiles(dir) {
+  const files = [];
+  try {
+    const entries = readdirSync(dir);
+    const priority = ["index.ts", "index.js", "main.ts", "main.js", "mod.ts", "__init__.py"];
+    for (const p of priority) {
+      if (entries.includes(p)) files.push(join(dir, p));
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry);
+      if (/\.(ts|js|tsx|jsx|py)$/.test(entry) && !files.includes(full)) {
+        files.push(full);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function safeReadFile(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const st = statSync(filePath);
+    if (st.size > 5e5) return null;
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function truncate(content) {
+  if (content.length <= MAX_FILE_CHARS) return content;
+  const t = content.slice(0, MAX_FILE_CHARS);
+  const lastNl = t.lastIndexOf("\n");
+  return t.slice(0, lastNl) + `
+... (truncated, ${content.length} chars total)`;
+}
+function safeGrep(pattern) {
+  try {
+    const result = execFileSync2("grep", [
+      "-rl",
+      "--include=*.ts",
+      "--include=*.js",
+      "--include=*.py",
+      "--include=*.md",
+      "-i",
+      pattern,
+      "."
+    ], { encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 1e4 });
+    return result.trim();
+  } catch {
+    return "";
+  }
+}
+function gitLog() {
+  try {
+    return execFileSync2("git", ["log", "--oneline", "-10"], {
+      encoding: "utf-8",
+      maxBuffer: 1024 * 1024,
+      timeout: 1e4
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function extractSearchHints(topic) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "have",
+    "has",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "about",
+    "and",
+    "but",
+    "or",
+    "not",
+    "this",
+    "that",
+    "my",
+    "your",
+    "what",
+    "how",
+    "review",
+    "discuss",
+    "plan",
+    "help",
+    "please",
+    "look",
+    "check",
+    "\u4E00\u4E0B",
+    "\u770B\u770B",
+    "\u5E2E",
+    "\u6211",
+    "\u7684",
+    "\u662F\u5426",
+    "\u600E\u4E48",
+    "\u5982\u4F55",
+    "\u8BA8\u8BBA",
+    "\u89C4\u5212",
+    "\u5BA1\u67E5"
+  ]);
+  return topic.split(/[\s,;:]+/).map((w) => w.toLowerCase().replace(/[^a-z0-9_\-/]/g, "")).filter((w) => w.length > 2 && !stopWords.has(w));
+}
+
+// src/arena/providers/docs.ts
+init_esm_shims();
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2, extname } from "path";
+var MAX_DOC_CHARS = 1e4;
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".rst", ".adoc", ".org"]);
+var docsProvider = {
+  kind: "docs",
+  collect(plan, topic) {
+    const artifacts = [];
+    const sourceSpec = plan.sources.find((s) => s.kind === "docs");
+    const targets = sourceSpec?.targets ?? [];
+    for (const target of targets) {
+      const content = safeReadDoc(target);
+      if (content) {
+        artifacts.push({
+          id: `doc-${target}`,
+          kind: "doc",
+          source: "docs",
+          title: target,
+          ref: target,
+          preview: truncate2(content)
+        });
+      }
+    }
+    if (targets.length === 0) {
+      const docDirs = ["docs", "doc", "design", "specs", "proposals", "."];
+      const found = /* @__PURE__ */ new Set();
+      for (const dir of docDirs) {
+        if (!existsSync2(dir)) continue;
+        const docs = findDocFiles(dir, 2);
+        for (const docPath of docs) {
+          if (found.has(docPath)) continue;
+          found.add(docPath);
+          const name = docPath.toLowerCase();
+          const topicLower = topic.toLowerCase();
+          const keywords = topicLower.split(/\s+/).filter((w) => w.length > 2);
+          const isRelevant = keywords.some((kw) => name.includes(kw));
+          if (isRelevant || found.size <= 5) {
+            const content = safeReadDoc(docPath);
+            if (content) {
+              artifacts.push({
+                id: `doc-${docPath}`,
+                kind: "doc",
+                source: "docs",
+                title: docPath,
+                ref: docPath,
+                preview: truncate2(content)
+              });
+            }
+          }
+        }
+      }
+    }
+    logger.info("arena.provider.docs", { artifactCount: artifacts.length });
+    return artifacts;
+  }
+};
+function findDocFiles(dir, maxDepth, depth = 0) {
+  if (depth >= maxDepth) return [];
+  const files = [];
+  try {
+    const entries = readdirSync2(dir);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules") continue;
+      const full = join2(dir, entry);
+      const st = statSync2(full);
+      if (st.isFile() && DOC_EXTENSIONS.has(extname(entry).toLowerCase())) {
+        files.push(full);
+      } else if (st.isDirectory() && depth < maxDepth - 1) {
+        files.push(...findDocFiles(full, maxDepth, depth + 1));
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function safeReadDoc(filePath) {
+  try {
+    if (!existsSync2(filePath)) return null;
+    const st = statSync2(filePath);
+    if (st.size > 5e5) return null;
+    return readFileSync2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function truncate2(content) {
+  if (content.length <= MAX_DOC_CHARS) return content;
+  const t = content.slice(0, MAX_DOC_CHARS);
+  const lastNl = t.lastIndexOf("\n");
+  return t.slice(0, lastNl) + `
+... (truncated, ${content.length} chars total)`;
+}
+
+// src/arena/providers/none.ts
+init_esm_shims();
+var noneProvider = {
+  kind: "none",
+  collect(_plan, _topic) {
+    return [];
+  }
+};
+
+// src/arena/providers/index.ts
+var PROVIDER_MAP = {
+  git: gitProvider,
+  repo: repoProvider,
+  docs: docsProvider,
+  web: noneProvider,
+  // web deferred to Phase 4 — falls back to none for now
+  none: noneProvider
+};
+function collectEvidence(plan, topic) {
+  const artifacts = [];
+  const quickFacts = [];
+  const seenSources = /* @__PURE__ */ new Set();
+  for (const sourceSpec of plan.sources) {
+    if (seenSources.has(sourceSpec.kind)) continue;
+    seenSources.add(sourceSpec.kind);
+    const provider = PROVIDER_MAP[sourceSpec.kind];
+    if (!provider) continue;
+    const collected = provider.collect(plan, topic);
+    artifacts.push(...collected);
+    logger.info("arena.evidence_collected", {
+      source: sourceSpec.kind,
+      count: collected.length
+    });
+  }
+  const branchArtifact = artifacts.find((a) => a.id === "git-branch");
+  if (branchArtifact) quickFacts.push({ label: "Branch", value: branchArtifact.preview });
+  const changedFilesArtifact = artifacts.find((a) => a.id === "git-changed-files");
+  if (changedFilesArtifact?.metadata?.totalCount) {
+    quickFacts.push({ label: "Changed Files", value: String(changedFilesArtifact.metadata.totalCount) });
+  }
+  const docCount = artifacts.filter((a) => a.source === "docs").length;
+  if (docCount > 0) quickFacts.push({ label: "Documents", value: String(docCount) });
+  quickFacts.push({ label: "Sources", value: [...seenSources].join(", ") });
+  quickFacts.push({ label: "Lenses", value: plan.lenses.map((l) => l.name).join(", ") });
+  return { artifacts, quickFacts };
+}
+
+// src/arena/tools/selector.ts
+init_esm_shims();
+
+// src/arena/context/context-tools.ts
+init_esm_shims();
+import { readFileSync as readFileSync3, existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import { resolve, join as join3 } from "path";
+var MAX_TOOL_RESULT = 15e3;
+var MAX_TOOL_ROUNDS = 5;
+var REPO_ROOT = resolve(".");
+var 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"]
+    }
+  }
+];
+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}`;
+  }
+}
+function validatePath(filePath) {
+  const resolved = resolve(filePath);
+  if (resolved === REPO_ROOT || resolved.startsWith(REPO_ROOT + "/")) {
+    return resolved;
+  }
+  return null;
+}
+function executeReadFile(args) {
+  const filePath = args.path;
+  if (!validatePath(filePath)) return `Error: path outside repository: ${filePath}`;
+  if (!existsSync3(filePath)) return `Error: file not found: ${filePath}`;
+  const raw = readFileSync3(filePath, "utf-8");
+  const lines = raw.split("\n");
+  const offset = Math.max(0, (args.offset ?? 1) - 1);
+  const limit = args.limit ?? 200;
+  const slice = lines.slice(offset, offset + limit);
+  const numbered = slice.map((l, i) => `${offset + i + 1}	${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 = readdirSync3(dir);
+    const lines = [];
+    for (const entry of entries.slice(0, 50)) {
+      const fullPath = join3(dir, entry);
+      try {
+        const st = statSync3(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}`;
+}
+function sanitizeGitRef(ref) {
+  if (!ref || ref.length > 200) return null;
+  const cleaned = ref.replace(/[^a-zA-Z0-9/_\-~^.:]/g, "");
+  if (/\.\.\/|;\s|&&|\|\||`|\$\(/.test(cleaned)) return null;
+  return cleaned || null;
+}
+function execFileSafe(cmd, args, maxLines) {
+  try {
+    const raw = execFileSync3(cmd, args, {
+      encoding: "utf-8",
+      maxBuffer: 512 * 1024,
+      timeout: 1e4
+    }).trim();
+    if (maxLines) {
+      const lines = raw.split("\n");
+      if (lines.length > maxLines) {
+        return lines.slice(0, maxLines).join("\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)";
+}
+
+// src/arena/tools/selector.ts
+var TOOL_PACKS = {
+  repo_readonly: {
+    name: "repo_readonly",
+    toolNames: ["read_file", "grep_code", "list_files"]
+  },
+  git: {
+    name: "git",
+    toolNames: ["read_file", "grep_code", "list_files", "git_show", "git_blame"]
+  },
+  docs: {
+    name: "docs",
+    toolNames: ["read_file", "list_files"]
+  },
+  no_tools: {
+    name: "no_tools",
+    toolNames: []
+  }
+};
+var SOURCE_TO_PACK = {
+  git: "git",
+  repo: "repo_readonly",
+  docs: "docs",
+  web: "no_tools",
+  // web tools not yet available in arena context
+  none: "no_tools"
+};
+function selectTools(plan) {
+  const toolNames = /* @__PURE__ */ new Set();
+  for (const source of plan.sources) {
+    const packName = source.toolPack ?? SOURCE_TO_PACK[source.kind] ?? "no_tools";
+    const pack = TOOL_PACKS[packName] ?? TOOL_PACKS.no_tools;
+    for (const name of pack.toolNames) {
+      toolNames.add(name);
+    }
+  }
+  if (toolNames.size === 0) return [];
+  return CONTEXT_TOOLS.filter((t) => toolNames.has(t.name));
+}
+function hasTools(plan) {
+  return plan.sources.some((s) => {
+    const packName = SOURCE_TO_PACK[s.kind];
+    const pack = TOOL_PACKS[packName];
+    return pack && pack.toolNames.length > 0;
+  });
+}
+
+// src/arena/phases/participant-research.ts
+init_esm_shims();
+import { createHash } from "crypto";
+async function runParticipantResearch(options) {
+  const results = await runParticipantResearchWithDossiers(options);
+  return results.map((r) => r.report);
+}
+async function runParticipantResearchWithDossiers(options) {
+  const { participants, strategy, topic, baseContext, enableContextTools, contextTools, signal, onProgress } = options;
+  const tools = enableContextTools ? contextTools ?? CONTEXT_TOOLS : void 0;
+  const tasks = participants.map(async (p) => {
+    onProgress?.({ type: "research_start", participant: p.name });
+    const client = await createLLMClient({
+      ...p.llm,
+      enableStreaming: false
+    });
+    const messages = [
+      {
+        role: "user",
+        content: strategy.researchUserPrompt(topic, baseContext)
+      }
+    ];
+    let finalText = "";
+    let totalRounds = 0;
+    const toolTraces = [];
+    const evidencePackets = [];
+    const MAX_MESSAGES = 30;
+    for (let round = 0; round <= MAX_TOOL_ROUNDS; round++) {
+      totalRounds = round;
+      if (messages.length >= MAX_MESSAGES) {
+        logger.warn("arena.research_message_limit", {
+          participant: p.name,
+          messageCount: messages.length,
+          round
+        });
+        break;
+      }
+      const response = await client.createMessage({
+        systemPrompt: strategy.researchSystemPrompt(p.name),
+        messages,
+        tools,
+        signal
+      });
+      const toolNames = (response.toolCalls ?? []).map((tc) => tc.toolName);
+      const hasTools2 = response.toolCalls && response.toolCalls.length > 0;
+      logger.info("arena.research_round", {
+        participant: p.name,
+        round,
+        toolCount: response.toolCalls?.length ?? 0,
+        toolNames,
+        textLen: response.text?.length ?? 0,
+        stopReason: response.stopReason ?? "unknown"
+      });
+      if (!hasTools2) {
+        finalText = response.text;
+        break;
+      }
+      onProgress?.({
+        type: "context_lookup",
+        participant: p.name,
+        tools: response.toolCalls.map((tc) => `${tc.toolName}(${JSON.stringify(tc.args)})`)
+      });
+      const assistantBlocks = [];
+      if (response.text) {
+        assistantBlocks.push({ type: "text", text: response.text });
+      }
+      for (const tc of response.toolCalls) {
+        assistantBlocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.toolName,
+          input: tc.args
+        });
+      }
+      messages.push({ role: "assistant", content: assistantBlocks });
+      const resultBlocks = [];
+      for (const tc of response.toolCalls) {
+        const result = executeContextTool(tc);
+        const trace = {
+          round,
+          toolName: tc.toolName,
+          args: tc.args,
+          resultRef: buildResultRef(tc),
+          keptAsEvidence: result.length > 50 && !result.startsWith("Error:") && !result.startsWith("Tool error:") && !result.startsWith("Unknown tool:")
+        };
+        toolTraces.push(trace);
+        if (trace.keptAsEvidence) {
+          const packet = buildEvidencePacketFromTool(p.name, tc, result, inferSourceKind(tc.toolName));
+          evidencePackets.push(packet);
+        }
+        resultBlocks.push({
+          type: "tool_result",
+          tool_use_id: tc.id,
+          content: result
+        });
+      }
+      messages.push({ role: "user", content: resultBlocks });
+    }
+    if (!finalText) {
+      logger.warn("arena.research_force_conclude", {
+        participant: p.name,
+        totalRounds,
+        messageCount: messages.length
+      });
+      const forceResponse = await client.createMessage({
+        systemPrompt: strategy.researchSystemPrompt(p.name),
+        messages: [
+          ...messages,
+          {
+            role: "user",
+            content: "You have gathered enough context. Based on ALL the tool results above, output your findings NOW.\n\nRespond ONLY with JSON \u2014 output your highest-confidence findings (typically 5-15 for a substantive topic; each finding's `summary` should be 80+ words with concrete evidence). Do NOT request any more tools. Just output the JSON."
+          }
+        ]
+      });
+      logger.info("arena.research_force_conclude_response", {
+        participant: p.name,
+        textLen: forceResponse.text?.length ?? 0,
+        stopReason: forceResponse.stopReason ?? "unknown"
+      });
+      finalText = forceResponse.text;
+    }
+    logger.info("arena.research_raw_response", {
+      participant: p.name,
+      textLength: finalText.length,
+      text: finalText
+    });
+    if (!finalText || finalText.trim().length === 0) {
+      logger.warn("arena.research_failed", {
+        participant: p.name,
+        totalRounds,
+        messageCount: messages.length
+      });
+      const failedReport = {
+        participant: p.name,
+        contextSummary: `(research failed: model returned empty response after ${totalRounds} tool rounds)`,
+        findings: []
+      };
+      const failedDossier = {
+        participant: p.name,
+        contextSummary: failedReport.contextSummary,
+        findings: [],
+        toolTrace: toolTraces,
+        evidencePackets,
+        findingEvidenceLinks: []
+      };
+      onProgress?.({ type: "research_done", participant: p.name, report: failedReport });
+      return { report: failedReport, dossier: failedDossier };
+    }
+    const report = strategy.parseResearchResponse(p.name, finalText);
+    const findingEvidenceLinks = buildFindingEvidenceLinks(report, evidencePackets);
+    const dossier = {
+      participant: p.name,
+      contextSummary: report.contextSummary,
+      findings: report.findings,
+      toolTrace: toolTraces,
+      evidencePackets,
+      findingEvidenceLinks
+    };
+    onProgress?.({ type: "research_done", participant: p.name, report });
+    return { report, dossier };
+  });
+  return Promise.all(tasks);
+}
+function buildResultRef(tc) {
+  if (tc.toolName === "read_file" && tc.args.path) return `file:${tc.args.path}`;
+  if (tc.toolName === "grep_code" && tc.args.pattern) return `grep:${tc.args.pattern}`;
+  if (tc.toolName === "list_files" && tc.args.path) return `dir:${tc.args.path}`;
+  if (tc.toolName === "git_show" && tc.args.ref) return `git:${tc.args.ref}`;
+  if (tc.toolName === "git_blame" && tc.args.path) return `blame:${tc.args.path}`;
+  return `${tc.toolName}:${JSON.stringify(tc.args).slice(0, 60)}`;
+}
+function generatePacketId(participant, source, ref, snippet) {
+  const hash = createHash("sha256").update(`${participant}:${source}:${ref}:${snippet.slice(0, 200)}`).digest("hex").slice(0, 12);
+  return `pkt-${hash}`;
+}
+function inferSourceKind(toolName) {
+  switch (toolName) {
+    case "git_show":
+    case "git_blame":
+      return "git";
+    case "read_file":
+    case "grep_code":
+    case "list_files":
+      return "repo";
+    default:
+      return "repo";
+  }
+}
+function buildEvidencePacketFromTool(participant, tc, result, source) {
+  const ref = buildResultRef(tc);
+  const snippet = result.slice(0, 500);
+  const packetId = generatePacketId(participant, source, ref, snippet);
+  return {
+    packetId,
+    participant,
+    source,
+    title: `${tc.toolName}: ${formatToolArgs(tc.args)}`,
+    refs: [ref],
+    summary: result.slice(0, 200),
+    excerpts: [{
+      ref,
+      snippet,
+      note: `Result of ${tc.toolName} call`
+    }]
+  };
+}
+function formatToolArgs(args) {
+  const parts = [];
+  for (const [key, value] of Object.entries(args)) {
+    if (typeof value === "string") parts.push(value.slice(0, 60));
+    else parts.push(`${key}=${JSON.stringify(value)}`);
+  }
+  return parts.join(", ").slice(0, 100);
+}
+function buildFindingEvidenceLinks(report, packets) {
+  const links = [];
+  for (const finding of report.findings) {
+    const matchedPacketIds = [];
+    for (const evidence of finding.evidence) {
+      const evidenceRef = `${evidence.type}:${evidence.ref}`;
+      for (const packet of packets) {
+        const matches = packet.refs.some((pRef) => {
+          if (pRef === evidenceRef) return true;
+          if (evidence.ref && pRef.includes(evidence.ref)) return true;
+          return false;
+        });
+        if (matches && !matchedPacketIds.includes(packet.packetId)) {
+          matchedPacketIds.push(packet.packetId);
+        }
+      }
+    }
+    if (matchedPacketIds.length > 0) {
+      links.push({
+        findingId: finding.id,
+        evidencePacketIds: matchedPacketIds
+      });
+    }
+  }
+  return links;
+}
+
+// src/arena/phases/claim-registry.ts
+init_esm_shims();
+function registerClaims(options) {
+  const { dossiers, ledger, onProgress } = options;
+  const claims = [];
+  for (const dossier of dossiers) {
+    const linkMap = /* @__PURE__ */ new Map();
+    for (const link of dossier.findingEvidenceLinks) {
+      linkMap.set(link.findingId, link.evidencePacketIds);
+    }
+    for (const finding of dossier.findings) {
+      const claimId = `${dossier.participant}:${finding.id}`;
+      const packetIds = linkMap.get(finding.id) ?? [];
+      const evidenceRefs = finding.evidence.map((e) => `${e.type}:${e.ref}`);
+      const claim = {
+        claimId,
+        owner: dossier.participant,
+        finding,
+        evidenceRefs,
+        evidencePacketIds: packetIds,
+        status: "proposed",
+        challenges: [],
+        debateRounds: []
+      };
+      claims.push(claim);
+      ledger.appendClaim(claim);
+    }
+  }
+  onProgress?.({ type: "claims_registered", claimCount: claims.length });
+  return claims;
+}
+function selectClaimsForReview(claims, maxClaims) {
+  const severityOrder = { high: 0, medium: 1, low: 2 };
+  const sorted = [...claims].sort((a, b) => {
+    const sevA = severityOrder[a.finding.severity ?? "medium"] ?? 1;
+    const sevB = severityOrder[b.finding.severity ?? "medium"] ?? 1;
+    if (sevA !== sevB) return sevA - sevB;
+    return b.finding.confidence - a.finding.confidence;
+  });
+  return sorted.slice(0, maxClaims);
+}
+
+// src/arena/digest-builder.ts
+init_esm_shims();
+function buildDigest(ledger, options) {
+  const { round, relevantClaimIds } = options;
+  const claimIdSet = new Set(relevantClaimIds);
+  const snapshot = ledger.getSnapshot();
+  const packetIds = /* @__PURE__ */ 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);
+  }
+  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
+        });
+      }
+    }
+  }
+  const recentChallenges = snapshot.challenges.filter((c) => claimIdSet.has(c.claimId));
+  const requestedChecks = snapshot.requestedChecks.filter((c) => claimIdSet.has(c.claimId));
+  const priorAdjudications = snapshot.adjudications.filter((a) => claimIdSet.has(a.claimId));
+  return {
+    round,
+    relevantClaimIds,
+    evidencePackets,
+    toolTraceSummary,
+    recentChallenges,
+    requestedChecks,
+    priorAdjudications
+  };
+}
+function sanitize(text) {
+  if (!text) return "";
+  return text.replace(/<\/?(?:system|assistant|user|system-reminder)[^>]*>/gi, "").replace(/^(?:IGNORE|DISREGARD|FORGET|OVERRIDE|SYSTEM|INSTRUCTION)[:\s].*/gim, "").replace(/\n{3,}/g, "\n\n").slice(0, 2e3);
+}
+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} \u2014 ${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} \u2014 ${sanitize(adj.rationale)}`);
+    }
+  }
+  return sections.join("\n");
+}
+
+// src/arena/transitions.ts
+init_esm_shims();
+var VALID_TRANSITIONS = {
+  proposed: ["under_review"],
+  under_review: ["verified", "contested", "rejected"],
+  contested: ["under_review", "unresolved", "verified", "rejected"],
+  verified: [],
+  rejected: [],
+  unresolved: []
+};
+function transitionClaim(claim, to) {
+  const allowed = VALID_TRANSITIONS[claim.status];
+  if (!allowed.includes(to)) {
+    return false;
+  }
+  claim.status = to;
+  return true;
+}
+function resolveClaimStatus(claim, challenges, hasPendingChecks) {
+  if (challenges.length === 0) return claim.status;
+  const verdicts = challenges.map((c) => c.verdict);
+  if (verdicts.includes("disagree") || verdicts.includes("needs_evidence")) {
+    return "contested";
+  }
+  if (hasPendingChecks) {
+    return "contested";
+  }
+  if (verdicts.includes("agree")) {
+    return "verified";
+  }
+  return claim.status;
+}
+function markUnderReview(claim) {
+  return transitionClaim(claim, "under_review");
+}
+function applyReviewResult(claim, challenges, hasPendingChecks) {
+  const nextStatus = resolveClaimStatus(claim, challenges, hasPendingChecks);
+  transitionClaim(claim, nextStatus);
+}
+function markUnresolved(claim) {
+  return transitionClaim(claim, "unresolved");
+}
+function isTerminal(claim) {
+  return VALID_TRANSITIONS[claim.status].length === 0;
+}
+function validTransitions(claim) {
+  return VALID_TRANSITIONS[claim.status];
+}
+
+// src/arena/phases/cross-review.ts
+init_esm_shims();
+async function runCrossReview(options) {
+  const { participants, strategy, topic, reports, signal, onProgress } = options;
+  onProgress?.({ type: "cross_review_start", round: 1 });
+  const allReviews = [];
+  const tasks = participants.map(async (p) => {
+    const myReport = reports.find((r) => r.participant === p.name);
+    const otherReports = reports.filter((r) => r.participant !== p.name);
+    if (otherReports.length === 0) return [];
+    if (!myReport) return [];
+    const client = await createLLMClient({
+      ...p.llm,
+      enableStreaming: false
+    });
+    const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
+    const userContent = strategy.crossReviewUserPrompt(topic, myReport, otherReports);
+    let response = await client.createMessage({
+      systemPrompt,
+      messages: [{ role: "user", content: userContent }],
+      signal
+    });
+    logger.info("arena.cross_review_raw_response", {
+      participant: p.name,
+      text: response.text,
+      stopReason: response.stopReason
+    });
+    if (response.stopReason === "length") {
+      logger.warn("arena.cross_review_truncated", { participant: p.name });
+      const retryResponse = await client.createMessage({
+        systemPrompt,
+        messages: [
+          { role: "user", content: userContent },
+          { role: "assistant", content: response.text },
+          {
+            role: "user",
+            content: "Your previous response was truncated. Please output the COMPLETE review JSON, using shorter comments. Respond ONLY with JSON."
+          }
+        ],
+        signal
+      });
+      logger.info("arena.cross_review_retry", {
+        participant: p.name,
+        stopReason: retryResponse.stopReason
+      });
+      response = retryResponse;
+    }
+    return strategy.parseCrossReviewResponse(p.name, response.text);
+  });
+  const results = await Promise.all(tasks);
+  for (const reviews of results) {
+    allReviews.push(...reviews);
+  }
+  onProgress?.({ type: "cross_review_done", reviews: allReviews });
+  return allReviews;
+}
+async function runVerificationReview(options) {
+  const { participants, strategy, topic, reports, ledger, limits, mode, signal, onProgress } = options;
+  const allClaims = ledger.getAllClaims();
+  const claimsToReview = selectClaimsForReview(allClaims, limits.maxClaimsForReview);
+  for (const claim of claimsToReview) {
+    markUnderReview(claim);
+  }
+  const relevantClaimIds = claimsToReview.map((c) => c.claimId);
+  const digest = buildDigest(ledger, { round: 1, relevantClaimIds });
+  const isPlanningMerge = mode === "planning" && isStrategyPlanning(strategy);
+  if (isPlanningMerge) {
+    onProgress?.({ type: "planning_merge_review_start" });
+  } else {
+    onProgress?.({ type: "verification_start" });
+  }
+  const v2 = isStrategyV2(strategy);
+  const allReviews = [];
+  const allChallenges = [];
+  const tasks = participants.map(async (p) => {
+    const myReport = reports.find((r) => r.participant === p.name);
+    const otherReports = reports.filter((r) => r.participant !== p.name);
+    if (!myReport || otherReports.length === 0) return;
+    const myClaims = claimsToReview.filter((c) => c.owner !== p.name);
+    if (myClaims.length === 0) return;
+    const client = await createLLMClient({
+      ...p.llm,
+      enableStreaming: false
+    });
+    const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
+    if (v2) {
+      const userContent = isPlanningMerge ? strategy.mergeReviewUserPrompt(topic, myReport, myClaims, digest) : strategy.verificationReviewUserPrompt(topic, myReport, myClaims, digest);
+      let response = await client.createMessage({
+        systemPrompt,
+        messages: [{ role: "user", content: userContent }],
+        signal
+      });
+      logger.info("arena.verification_review_raw", {
+        participant: p.name,
+        stopReason: response.stopReason
+      });
+      if (response.stopReason === "length") {
+        const retryResponse = await client.createMessage({
+          systemPrompt,
+          messages: [
+            { role: "user", content: userContent },
+            { role: "assistant", content: response.text },
+            { role: "user", content: "Truncated. Output the COMPLETE JSON array, shorter comments. JSON only." }
+          ],
+          signal
+        });
+        response = retryResponse;
+      }
+      const challenges = isPlanningMerge ? strategy.parseMergeReviewResponse(p.name, response.text) : strategy.parseVerificationReviewResponse(p.name, response.text);
+      for (const challenge of challenges) {
+        allChallenges.push(challenge);
+        ledger.appendChallenge(challenge);
+      }
+      for (const ch of challenges) {
+        allReviews.push({
+          reviewer: ch.reviewer,
+          findingId: ch.claimId,
+          verdict: ch.verdict,
+          reason: ch.reason,
+          extraEvidence: ch.supportingEvidenceRefs
+        });
+      }
+    } else {
+      const userContent = strategy.crossReviewUserPrompt(topic, myReport, otherReports);
+      let response = await client.createMessage({
+        systemPrompt,
+        messages: [{ role: "user", content: userContent }],
+        signal
+      });
+      if (response.stopReason === "length") {
+        const retryResponse = await client.createMessage({
+          systemPrompt,
+          messages: [
+            { role: "user", content: userContent },
+            { role: "assistant", content: response.text },
+            { role: "user", content: "Truncated. Output COMPLETE review JSON. Shorter comments. JSON only." }
+          ],
+          signal
+        });
+        response = retryResponse;
+      }
+      const reviews = strategy.parseCrossReviewResponse(p.name, response.text);
+      allReviews.push(...reviews);
+      for (const review of reviews) {
+        const claim = claimsToReview.find(
+          (c) => c.finding.id === review.findingId || c.claimId === review.findingId
+        );
+        if (claim) {
+          const challenge = {
+            reviewer: review.reviewer,
+            claimId: claim.claimId,
+            verdict: review.verdict,
+            reason: review.reason,
+            supportingEvidenceRefs: review.extraEvidence
+          };
+          allChallenges.push(challenge);
+          ledger.appendChallenge(challenge);
+        }
+      }
+    }
+  });
+  await Promise.all(tasks);
+  for (const claim of claimsToReview) {
+    const claimChallenges = ledger.getChallengesForClaim(claim.claimId);
+    const hasPendingChecks = ledger.getPendingChecksForClaim(claim.claimId).length > 0;
+    applyReviewResult(claim, claimChallenges, hasPendingChecks);
+  }
+  logger.info("arena.verification_done", {
+    reviewCount: allReviews.length,
+    challengeCount: allChallenges.length,
+    claimStatuses: Object.fromEntries(
+      claimsToReview.map((c) => [c.claimId, c.status])
+    )
+  });
+  if (isPlanningMerge) {
+    onProgress?.({ type: "planning_merge_review_done", mergeCount: allChallenges.length });
+  } else {
+    onProgress?.({ type: "verification_done", challengeCount: allChallenges.length });
+  }
+  onProgress?.({ type: "cross_review_done", reviews: allReviews });
+  return { reviews: allReviews, challenges: allChallenges };
+}
+
+// src/arena/phases/debate-rounds.ts
+init_esm_shims();
+async function runDebateRounds(options) {
+  const { participants, strategy, topic, ledger, limits, maxRounds, signal, onProgress } = options;
+  const contested = ledger.getClaimsByStatus("contested").slice(0, limits.maxContestedClaimsForDebate);
+  if (contested.length === 0) {
+    logger.info("arena.debate_skip", { reason: "no contested claims" });
+    return [];
+  }
+  logger.info("arena.debate_start", {
+    contestedCount: contested.length,
+    maxRounds
+  });
+  const allDebateRounds = [];
+  const v2 = isStrategyV2(strategy);
+  for (const claim of contested) {
+    signal?.throwIfAborted();
+    const claimDebateRounds = await debateClaim({
+      claim,
+      participants,
+      strategy,
+      v2,
+      topic,
+      ledger,
+      maxRounds,
+      signal,
+      onProgress
+    });
+    allDebateRounds.push(...claimDebateRounds);
+    claim.debateRounds.push(...claimDebateRounds);
+  }
+  return allDebateRounds;
+}
+async function debateClaim(options) {
+  const { claim, participants, strategy, v2, topic, ledger, maxRounds, signal, onProgress } = options;
+  const owner = participants.find((p) => p.name === claim.owner);
+  const primaryChallenger = findPrimaryChallenger(claim, participants);
+  if (!owner || !primaryChallenger) {
+    logger.warn("arena.debate_skip_claim", {
+      claimId: claim.claimId,
+      reason: "cannot identify debaters"
+    });
+    return [];
+  }
+  const debaters = [owner, primaryChallenger];
+  const rounds = [];
+  const allTurns = [];
+  for (let round = 1; round <= maxRounds; round++) {
+    signal?.throwIfAborted();
+    onProgress?.({ type: "debate_round_start", round, claims: [claim.claimId] });
+    const digest = buildDigest(ledger, {
+      round,
+      relevantClaimIds: [claim.claimId]
+    });
+    const turnPromises = debaters.map(async (p) => {
+      const client = await createLLMClient({
+        ...p.llm,
+        enableStreaming: false
+      });
+      const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
+      let userContent;
+      if (v2) {
+        userContent = strategy.debateTurnUserPrompt(topic, claim, allTurns, digest);
+      } else {
+        userContent = buildFallbackDebatePrompt(topic, claim, allTurns);
+      }
+      const response = await client.createMessage({
+        systemPrompt,
+        messages: [{ role: "user", content: userContent }],
+        signal
+      });
+      logger.info("arena.debate_turn", {
+        participant: p.name,
+        claimId: claim.claimId,
+        round,
+        stopReason: response.stopReason
+      });
+      if (v2) {
+        return strategy.parseDebateTurnResponse(p.name, response.text);
+      }
+      return parseDebateTurn(p.name, response.text);
+    });
+    const turns = await Promise.all(turnPromises);
+    allTurns.push(...turns);
+    const resolved = turns.every((t) => t.stance === "support" || t.stance === "narrow");
+    const resolutionNote = resolved ? `Converged in round ${round}: ${turns.map((t) => `${t.participant}=${t.stance}`).join(", ")}` : void 0;
+    const debateRound = {
+      round,
+      claimId: claim.claimId,
+      participants: turns,
+      resolved,
+      resolutionNote
+    };
+    rounds.push(debateRound);
+    onProgress?.({ type: "debate_round_done", round, resolved: resolved ? 1 : 0 });
+    if (resolved) {
+      logger.info("arena.debate_converged", {
+        claimId: claim.claimId,
+        round
+      });
+      break;
+    }
+  }
+  return rounds;
+}
+function findPrimaryChallenger(claim, participants) {
+  const disagreeChallenge = claim.challenges.find((c) => c.verdict === "disagree");
+  const needsEvidenceChallenge = claim.challenges.find((c) => c.verdict === "needs_evidence");
+  const challenge = disagreeChallenge ?? needsEvidenceChallenge ?? claim.challenges[0];
+  if (!challenge) return void 0;
+  return participants.find((p) => p.name === challenge.reviewer);
+}
+function buildFallbackDebatePrompt(topic, claim, priorTurns) {
+  const turnsText = priorTurns.length > 0 ? priorTurns.map((t) => `[${t.participant}] ${t.stance}: ${t.summary}`).join("\n") : "No prior turns.";
+  return `## Topic: ${topic}
+
+## Contested Claim
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+
+## Prior Debate
+${turnsText}
+
+State your position on this claim. Build on prior turns: cite specific evidence, acknowledge counter-arguments, and explain your reasoning in 150-300 words. Brevity here means missed nuance \u2014 depth wins.
+Respond ONLY with JSON:
+{"stance": "support|oppose|narrow|uncertain", "summary": "your argument", "newEvidenceRefs": ["optional"]}`;
+}
+
+// src/arena/phases/adjudication.ts
+init_esm_shims();
+async function runAdjudication(options) {
+  const { concluder, strategy, topic, ledger, signal, onProgress } = options;
+  const allAdjudications = [];
+  const v2 = isStrategyV2(strategy);
+  const contestedClaims = ledger.getClaimsByStatus("contested");
+  const verifiedClaims = ledger.getClaimsByStatus("verified");
+  if (contestedClaims.length === 0 && verifiedClaims.length === 0) {
+    logger.info("arena.adjudication_skip", { reason: "no claims to adjudicate" });
+    return [];
+  }
+  logger.info("arena.adjudication_start", {
+    contested: contestedClaims.length,
+    verified: verifiedClaims.length
+  });
+  const client = await createLLMClient({
+    ...concluder.llm,
+    enableStreaming: false
+  });
+  for (const claim of contestedClaims) {
+    signal?.throwIfAborted();
+    const digest = buildDigest(ledger, {
+      round: 0,
+      // adjudication is post-debate
+      relevantClaimIds: [claim.claimId]
+    });
+    const systemPrompt = strategy.consensusSystemPrompt();
+    let userContent;
+    if (v2) {
+      userContent = strategy.adjudicationUserPrompt(topic, claim, claim.debateRounds, digest);
+    } else {
+      userContent = buildFallbackAdjudicationPrompt(topic, claim);
+    }
+    const response = await client.createMessage({
+      systemPrompt,
+      messages: [{ role: "user", content: userContent }],
+      signal
+    });
+    logger.info("arena.adjudication_response", {
+      claimId: claim.claimId,
+      stopReason: response.stopReason
+    });
+    let adjudication;
+    if (v2) {
+      adjudication = strategy.parseAdjudicationResponse(response.text);
+      adjudication.claimId = claim.claimId;
+    } else {
+      adjudication = parseAdjudication(claim.claimId, response.text);
+    }
+    ledger.appendAdjudication(adjudication);
+    allAdjudications.push(adjudication);
+    applyAdjudicationOutcome(claim, adjudication);
+  }
+  for (const claim of verifiedClaims) {
+    const adjudication = {
+      claimId: claim.claimId,
+      outcome: "accepted",
+      rationale: "Verified by peer review without contest",
+      finalSummary: claim.finding.summary,
+      supportingEvidenceRefs: claim.evidenceRefs
+    };
+    ledger.appendAdjudication(adjudication);
+    allAdjudications.push(adjudication);
+  }
+  const remaining = ledger.getClaimsByStatus("proposed", "under_review");
+  for (const claim of remaining) {
+    markUnresolved(claim);
+  }
+  const accepted = allAdjudications.filter(
+    (a) => a.outcome === "accepted" || a.outcome === "accepted_with_revision"
+  ).length;
+  const unresolved = ledger.getClaimsByStatus("unresolved").length;
+  logger.info("arena.adjudication_done", {
+    total: allAdjudications.length,
+    accepted,
+    unresolved
+  });
+  onProgress?.({ type: "adjudication_done", accepted, unresolved });
+  return allAdjudications;
+}
+function applyAdjudicationOutcome(claim, adjudication) {
+  switch (adjudication.outcome) {
+    case "accepted":
+    case "accepted_with_revision":
+      transitionClaim(claim, "verified");
+      break;
+    case "rejected":
+      transitionClaim(claim, "rejected");
+      break;
+    case "unresolved":
+      markUnresolved(claim);
+      break;
+  }
+}
+function buildFallbackAdjudicationPrompt(topic, claim) {
+  const challengeText = claim.challenges.length > 0 ? claim.challenges.map((c) => `[${c.reviewer}] ${c.verdict}: ${c.reason}`).join("\n") : "No challenges.";
+  const debateText = claim.debateRounds.length > 0 ? claim.debateRounds.map(
+    (r) => `Round ${r.round}:
+` + r.participants.map((t) => `  [${t.participant}] ${t.stance}: ${t.summary}`).join("\n") + `
+  ${r.resolved ? "\u2192 Resolved" : "\u2192 Unresolved"}`
+  ).join("\n\n") : "No debate rounds.";
+  return `## Topic: ${topic}
+
+## Claim Under Adjudication
+[${claim.claimId}] ${claim.finding.title}
+${claim.finding.summary}
+Owner: ${claim.owner} | Status: ${claim.status}
+
+## Challenges
+${challengeText}
+
+## Debate
+${debateText}
+
+As moderator, adjudicate this claim based on all available evidence.
+Respond ONLY with JSON:
+{"outcome": "accepted|accepted_with_revision|rejected|unresolved", "rationale": "...", "finalSummary": "revised claim summary if needed", "supportingEvidenceRefs": ["..."]}`;
+}
+
+// src/arena/phases/build-consensus.ts
+init_esm_shims();
+async function buildConsensus(options) {
+  const { concluder, strategy, topic, reports, reviews, claimSummary, signal, onProgress } = options;
+  onProgress?.({ type: "consensus_start" });
+  const client = await createLLMClient({
+    ...concluder.llm,
+    enableStreaming: false
+  });
+  const systemPrompt = strategy.consensusSystemPrompt();
+  let userContent;
+  const v2 = isStrategyV2(strategy);
+  if (v2 && claimSummary) {
+    userContent = strategy.claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary);
+    logger.info("arena.consensus_claim_aware", {
+      verified: claimSummary.verified.length,
+      unresolved: claimSummary.unresolved.length,
+      contested: claimSummary.contested.length,
+      rejected: claimSummary.rejected.length
+    });
+  } else {
+    userContent = strategy.consensusUserPrompt(topic, reports, reviews);
+  }
+  const response = await client.createMessage({
+    systemPrompt,
+    messages: [{ role: "user", content: userContent }],
+    signal
+  });
+  logger.info("arena.consensus_raw_response", {
+    text: response.text,
+    stopReason: response.stopReason
+  });
+  if (response.stopReason === "length") {
+    logger.warn("arena.consensus_truncated", {
+      textLen: response.text?.length ?? 0,
+      maxTokens: concluder.llm.maxTokens
+    });
+    const retryResponse = await client.createMessage({
+      systemPrompt,
+      messages: [
+        { role: "user", content: userContent },
+        { role: "assistant", content: response.text },
+        {
+          role: "user",
+          content: "Your previous response was truncated. Please output a COMPLETE but more concise version of the consensus JSON. Keep all sections but use shorter summaries. Respond ONLY with the complete JSON object."
+        }
+      ],
+      signal
+    });
+    logger.info("arena.consensus_retry_response", {
+      textLen: retryResponse.text?.length ?? 0,
+      stopReason: retryResponse.stopReason
+    });
+    if (retryResponse.stopReason === "length") {
+      logger.warn("arena.consensus_still_truncated", {
+        textLen: retryResponse.text?.length ?? 0
+      });
+    }
+    const consensus2 = strategy.parseConsensusResponse(retryResponse.text);
+    onProgress?.({ type: "consensus_done", consensus: consensus2 });
+    return consensus2;
+  }
+  const consensus = strategy.parseConsensusResponse(response.text);
+  onProgress?.({ type: "consensus_done", consensus });
+  return consensus;
+}
+
+// src/arena/ledger.ts
+init_esm_shims();
+var WARN_CLAIMS = 50;
+var WARN_PACKETS = 200;
+var WARN_CHALLENGES = 100;
+var ArenaLedger = class {
+  ledger;
+  index;
+  constructor() {
+    this.ledger = {
+      dossiers: [],
+      evidencePackets: [],
+      toolTraces: [],
+      claims: [],
+      challenges: [],
+      requestedChecks: [],
+      adjudications: []
+    };
+    this.index = {
+      claimsById: /* @__PURE__ */ new Map(),
+      packetsById: /* @__PURE__ */ new Map(),
+      requestsById: /* @__PURE__ */ 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) {
+    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);
+    const claim = this.index.claimsById.get(challenge.claimId);
+    if (claim) {
+      claim.challenges.push(challenge);
+    }
+    this.checkGrowth();
+    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);
+    const claim = this.index.claimsById.get(adjudication.claimId);
+    if (claim) {
+      claim.adjudication = adjudication;
+    }
+  }
+  // ─── 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 !== void 0);
+  }
+  getDossiers() {
+    return this.ledger.dossiers;
+  }
+  getDossierByParticipant(participant) {
+    const dossiers = this.ledger.dossiers.filter((d) => d.participant === participant);
+    return dossiers[dossiers.length - 1];
+  }
+};
+
+// src/arena/arena.ts
+init_esm_shims();
+
+// src/arena/phases/planning-detail-expansion.ts
+init_esm_shims();
+var MAX_EXPANSION_TOOL_ROUNDS = 3;
+async function runDetailExpansion(options) {
+  const { concluder, strategy, topic, phases, ledger, limits, signal, onProgress } = options;
+  const tools = options.enableContextTools !== false ? options.contextTools ?? CONTEXT_TOOLS : void 0;
+  const toExpand = phases.slice(0, limits.maxExpandedPhasesPerRun);
+  onProgress?.({ type: "roadmap_expansion_start", phaseCount: toExpand.length });
+  logger.info("arena.detail_expansion_start", { phaseCount: toExpand.length });
+  const details = [];
+  const client = await createLLMClient({
+    ...concluder.llm,
+    enableStreaming: false
+  });
+  const systemPrompt = strategy.detailExpansionSystemPrompt();
+  for (const phase of toExpand) {
+    signal?.throwIfAborted();
+    const relevantClaimIds = phase.relatedFindings ?? [];
+    const digest = buildDigest(ledger, { round: 1, relevantClaimIds });
+    const userContent = strategy.detailExpansionUserPrompt(topic, phase, digest);
+    const messages = [{ role: "user", content: userContent }];
+    let finalText = "";
+    const maxRounds = tools ? Math.min(MAX_EXPANSION_TOOL_ROUNDS, MAX_TOOL_ROUNDS) : 0;
+    for (let round = 0; round <= maxRounds; round++) {
+      const response = await client.createMessage({
+        systemPrompt,
+        messages,
+        tools,
+        signal
+      });
+      const hasTools2 = response.toolCalls && response.toolCalls.length > 0;
+      logger.info("arena.detail_expansion_round", {
+        phase: phase.title,
+        round,
+        toolCount: response.toolCalls?.length ?? 0,
+        stopReason: response.stopReason
+      });
+      if (!hasTools2) {
+        finalText = response.text;
+        break;
+      }
+      const assistantBlocks = [];
+      if (response.text) {
+        assistantBlocks.push({ type: "text", text: response.text });
+      }
+      for (const tc of response.toolCalls) {
+        assistantBlocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.toolName,
+          input: tc.args
+        });
+      }
+      messages.push({ role: "assistant", content: assistantBlocks });
+      const toolResultBlocks = [];
+      for (const tc of response.toolCalls) {
+        const result = executeContextTool(tc);
+        toolResultBlocks.push({
+          type: "tool_result",
+          tool_use_id: tc.id,
+          content: result.slice(0, 15e3)
+        });
+      }
+      messages.push({ role: "user", content: toolResultBlocks });
+      if (round === maxRounds) {
+        finalText = response.text;
+      }
+    }
+    if (!finalText) {
+      finalText = "";
+    }
+    logger.info("arena.detail_expansion_phase", {
+      phase: phase.title,
+      textLen: finalText.length
+    });
+    const detail = strategy.parseDetailExpansionResponse(finalText);
+    if (!detail.phaseTitle) detail.phaseTitle = phase.title;
+    if (detail.targetFiles.length === 0 && detail.codeChanges.length === 0) {
+      logger.warn("arena.detail_expansion_sparse", {
+        phase: phase.title,
+        objective: detail.objective.slice(0, 200)
+      });
+    }
+    details.push(detail);
+  }
+  logger.info("arena.detail_expansion_done", { detailCount: details.length });
+  onProgress?.({ type: "roadmap_expansion_done", detailCount: details.length });
+  return details;
+}
+
+// src/arena/strategies/language-wrapper.ts
+init_esm_shims();
+function detectLanguageInstruction(topic) {
+  const nonAscii = topic.replace(/[\x00-\x7F]/g, "");
+  const ratio = nonAscii.length / Math.max(topic.length, 1);
+  if (ratio < 0.15) return "";
+  if (/[\u4e00-\u9fff\u3400-\u4dbf]/.test(topic)) {
+    return "IMPORTANT: The user's query is in Chinese. You MUST respond in Chinese (\u4E2D\u6587). All text output \u2014 summaries, findings, titles, descriptions, rationale \u2014 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 (\u65E5\u672C\u8A9E). 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 (\uD55C\uAD6D\uC5B4). 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 (\u0440\u0443\u0441\u0441\u043A\u0438\u0439). 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 (\u0627\u0644\u0639\u0631\u0628\u064A\u0629). All text output must be in Arabic. JSON field values must be in Arabic.";
+  }
+  return "IMPORTANT: Respond in the same language as the user's query. All text output \u2014 summaries, findings, titles, descriptions \u2014 must match the query language.";
+}
+function withLanguage(strategy, topic) {
+  const langInstruction = detectLanguageInstruction(topic);
+  if (!langInstruction) return strategy;
+  return {
+    researchSystemPrompt(name) {
+      return `${langInstruction}
+
+${strategy.researchSystemPrompt(name)}`;
+    },
+    researchUserPrompt(t, ctx) {
+      return strategy.researchUserPrompt(t, ctx);
+    },
+    parseResearchResponse(participant, text) {
+      return strategy.parseResearchResponse(participant, text);
+    },
+    crossReviewSystemPrompt(reviewerName) {
+      return `${langInstruction}
+
+${strategy.crossReviewSystemPrompt(reviewerName)}`;
+    },
+    crossReviewUserPrompt(t, my, others) {
+      return strategy.crossReviewUserPrompt(t, my, others);
+    },
+    parseCrossReviewResponse(reviewer, text) {
+      return strategy.parseCrossReviewResponse(reviewer, text);
+    },
+    consensusSystemPrompt() {
+      return `${langInstruction}
+
+${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(topic2, myReport, claims, digest) {
+        return strategy.verificationReviewUserPrompt(topic2, myReport, claims, digest);
+      },
+      parseVerificationReviewResponse(reviewer, text) {
+        return strategy.parseVerificationReviewResponse(reviewer, text);
+      },
+      debateTurnUserPrompt(topic2, claim, priorTurns, digest) {
+        return strategy.debateTurnUserPrompt(topic2, claim, priorTurns, digest);
+      },
+      parseDebateTurnResponse(participant, text) {
+        return strategy.parseDebateTurnResponse(participant, text);
+      },
+      adjudicationUserPrompt(topic2, claim, rounds, digest) {
+        return strategy.adjudicationUserPrompt(topic2, claim, rounds, digest);
+      },
+      parseAdjudicationResponse(text) {
+        return strategy.parseAdjudicationResponse(text);
+      },
+      claimAwareConsensusUserPrompt(topic2, reports, reviews, claimSummary) {
+        return strategy.claimAwareConsensusUserPrompt(topic2, reports, reviews, claimSummary);
+      }
+    } : {}
+  };
+}
+
+// src/arena/arena.ts
+var Arena = class {
+  config;
+  strategy;
+  limits;
+  constructor(config) {
+    if (config.participants.length < 2) {
+      throw new Error("Arena requires at least 2 participants");
+    }
+    const mode = config.mode ?? "review";
+    const defaults = ARENA_MODE_DEFAULTS[mode];
+    this.config = {
+      mode,
+      maxDiscussionRounds: config.maxDiscussionRounds ?? defaults.maxDiscussionRounds,
+      ...config
+    };
+    this.limits = config.executionLimits ?? DEFAULT_EXECUTION_LIMITS;
+    this.strategy = config.strategy ?? getStrategy(mode);
+  }
+  /**
+   * Run a full arena session.
+   *
+   * @param topic  - User's topic/request (natural language)
+   * @param flags  - Optional explicit overrides (mode, base, head)
+   */
+  async run(topic, flags) {
+    const participantNames = this.config.participants.map((p) => p.name);
+    const signal = this.config.signal;
+    logger.info("arena.start", { mode: this.config.mode, participants: participantNames });
+    signal?.throwIfAborted();
+    const llmConfig = this.config.participants[0].llm;
+    const plan = await planArena(topic, llmConfig, flags, signal);
+    this.config.onProgress?.({ type: "plan_resolved", plan });
+    logger.info("arena.plan", {
+      mode: plan.mode,
+      lenses: plan.lenses.map((l) => l.name),
+      sources: plan.sources.map((s) => s.kind),
+      subject: plan.subject.label,
+      confidence: plan.confidence
+    });
+    if (!flags?.mode && plan.mode !== this.config.mode) {
+      this.config.mode = plan.mode;
+    }
+    signal?.throwIfAborted();
+    const { artifacts, quickFacts } = collectEvidence(plan, topic);
+    this.config.onProgress?.({ type: "evidence_collected", artifacts });
+    logger.info("arena.evidence", {
+      artifactCount: artifacts.length,
+      sources: plan.sources.map((s) => s.kind)
+    });
+    const baseContext = { plan, artifacts, quickFacts };
+    this.strategy = this.config.strategy ?? getStrategyForPlan(plan);
+    this.strategy = withLanguage(this.strategy, topic);
+    const contextTools = this.config.enableContextTools !== false ? selectTools(plan) : void 0;
+    signal?.throwIfAborted();
+    logger.info("arena.research_phase", { participants: participantNames });
+    const researchResults = await runParticipantResearchWithDossiers({
+      participants: this.config.participants,
+      strategy: this.strategy,
+      topic,
+      baseContext,
+      enableContextTools: this.config.enableContextTools ?? true,
+      contextTools,
+      signal,
+      onProgress: this.config.onProgress
+    });
+    const reports = researchResults.map((r) => r.report);
+    const dossiers = researchResults.map((r) => r.dossier);
+    signal?.throwIfAborted();
+    const ledger = new ArenaLedger();
+    for (const dossier of dossiers) {
+      ledger.appendDossier(dossier);
+    }
+    const claims = registerClaims({
+      dossiers,
+      ledger,
+      onProgress: this.config.onProgress
+    });
+    logger.info("arena.claims_registered", {
+      claimCount: claims.length,
+      byOwner: Object.fromEntries(
+        participantNames.map((name) => [
+          name,
+          claims.filter((c) => c.owner === name).length
+        ])
+      )
+    });
+    signal?.throwIfAborted();
+    const concluderName = this.config.concluder ?? participantNames[0];
+    const concluderMatch = this.config.participants.find((p) => p.name === concluderName);
+    if (!concluderMatch && this.config.concluder) {
+      logger.warn("arena.concluder_not_found", {
+        requested: this.config.concluder,
+        fallback: this.config.participants[0].name
+      });
+    }
+    const concluder = concluderMatch ?? this.config.participants[0];
+    const enableTools = this.config.enableContextTools !== false;
+    if (this.config.mode === "planning") {
+      return this.runPlanningPath({
+        topic,
+        participantNames,
+        plan,
+        baseContext,
+        reports,
+        dossiers,
+        ledger,
+        concluder,
+        contextTools,
+        enableContextTools: enableTools,
+        signal
+      });
+    }
+    return this.runReviewDiscussionPath({
+      topic,
+      participantNames,
+      plan,
+      baseContext,
+      reports,
+      dossiers,
+      ledger,
+      concluder,
+      signal
+    });
+  }
+  /**
+   * Planning path: merge-oriented review → roadmap consensus → detail expansion.
+   *
+   * Planning mode does NOT enter heavy debate/adjudication. Contested findings
+   * are converted to open questions or dependency risks in the roadmap.
+   */
+  async runPlanningPath(ctx) {
+    const {
+      topic,
+      participantNames,
+      plan,
+      baseContext,
+      reports,
+      dossiers,
+      ledger,
+      concluder,
+      contextTools,
+      enableContextTools,
+      signal
+    } = ctx;
+    logger.info("arena.planning_merge_review_phase");
+    const { reviews } = await runVerificationReview({
+      participants: this.config.participants,
+      strategy: this.strategy,
+      topic,
+      reports,
+      ledger,
+      limits: this.limits,
+      mode: "planning",
+      signal,
+      onProgress: this.config.onProgress
+    });
+    signal?.throwIfAborted();
+    const allClaims = ledger.getAllClaims();
+    const claimSummary = {
+      verified: allClaims.filter((c) => c.status === "verified"),
+      contested: allClaims.filter((c) => c.status === "contested"),
+      unresolved: allClaims.filter((c) => c.status === "unresolved"),
+      rejected: allClaims.filter((c) => c.status === "rejected")
+    };
+    logger.info("arena.planning_consensus_phase", { concluder: concluder.name });
+    const consensus = await buildConsensus({
+      concluder,
+      strategy: this.strategy,
+      topic,
+      reports,
+      reviews,
+      claimSummary,
+      signal,
+      onProgress: this.config.onProgress
+    });
+    signal?.throwIfAborted();
+    if (consensus.roadmap.length > 0 && isStrategyPlanning(this.strategy)) {
+      logger.info("arena.detail_expansion_phase", { phaseCount: consensus.roadmap.length });
+      try {
+        const details = await runDetailExpansion({
+          concluder,
+          strategy: this.strategy,
+          topic,
+          phases: consensus.roadmap,
+          ledger,
+          limits: this.limits,
+          enableContextTools,
+          contextTools,
+          signal,
+          onProgress: this.config.onProgress
+        });
+        consensus.roadmapDetails = details;
+      } catch (err) {
+        logger.warn("arena.detail_expansion_failed", {
+          error: err.message,
+          phaseCount: consensus.roadmap.length
+        });
+      }
+    }
+    return {
+      topic,
+      mode: this.config.mode,
+      participants: participantNames,
+      plan,
+      baseContext,
+      reports,
+      dossiers,
+      claims: allClaims,
+      reviews,
+      consensus
+    };
+  }
+  /**
+   * Review/Discussion path: verification review → debate → adjudication → consensus.
+   *
+   * This is the heavy trust loop for claim verification.
+   */
+  async runReviewDiscussionPath(ctx) {
+    const { topic, participantNames, plan, baseContext, reports, dossiers, ledger, concluder, signal } = ctx;
+    logger.info("arena.verification_review_phase");
+    const { reviews } = await runVerificationReview({
+      participants: this.config.participants,
+      strategy: this.strategy,
+      topic,
+      reports,
+      ledger,
+      limits: this.limits,
+      signal,
+      onProgress: this.config.onProgress
+    });
+    signal?.throwIfAborted();
+    logger.info("arena.debate_phase");
+    const debateRounds = await runDebateRounds({
+      participants: this.config.participants,
+      strategy: this.strategy,
+      topic,
+      ledger,
+      limits: this.limits,
+      maxRounds: this.config.maxDiscussionRounds,
+      signal,
+      onProgress: this.config.onProgress
+    });
+    signal?.throwIfAborted();
+    logger.info("arena.adjudication_phase", { concluder: concluder.name });
+    const adjudications = await runAdjudication({
+      concluder,
+      strategy: this.strategy,
+      topic,
+      ledger,
+      signal,
+      onProgress: this.config.onProgress
+    });
+    signal?.throwIfAborted();
+    const allClaims = ledger.getAllClaims();
+    const claimSummary = {
+      verified: allClaims.filter((c) => c.status === "verified"),
+      contested: allClaims.filter((c) => c.status === "contested"),
+      unresolved: allClaims.filter((c) => c.status === "unresolved"),
+      rejected: allClaims.filter((c) => c.status === "rejected")
+    };
+    logger.info("arena.consensus_phase", {
+      concluder: concluder.name,
+      verified: claimSummary.verified.length,
+      unresolved: claimSummary.unresolved.length
+    });
+    const consensus = await buildConsensus({
+      concluder,
+      strategy: this.strategy,
+      topic,
+      reports,
+      reviews,
+      claimSummary,
+      signal,
+      onProgress: this.config.onProgress
+    });
+    return {
+      topic,
+      mode: this.config.mode,
+      participants: participantNames,
+      plan,
+      baseContext,
+      reports,
+      dossiers,
+      claims: allClaims,
+      reviews,
+      debateRounds,
+      adjudications,
+      consensus
+    };
+  }
+};
+
+// src/arena/model-presets.ts
+init_esm_shims();
+var MODEL_PRESETS = {
+  claude: { provider: "openai", model: "anthropic/claude-opus-4.6", maxOutputTokens: 32e3 },
+  "claude-sonnet": { provider: "openai", model: "anthropic/claude-sonnet-4.6", maxOutputTokens: 16e3 },
+  "claude-haiku": { provider: "openai", model: "anthropic/claude-haiku-4.5", maxOutputTokens: 8192 },
+  gpt: { provider: "openai", model: "openai/gpt-5.4", maxOutputTokens: 32e3 },
+  "gpt4o": { provider: "openai", model: "openai/gpt-4o", maxOutputTokens: 16384 },
+  o4: { provider: "openai", model: "openai/o4-mini", maxOutputTokens: 1e5 },
+  o3: { provider: "openai", model: "openai/o3", maxOutputTokens: 1e5 },
+  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: 32e3 },
+  devstral: { provider: "openai", model: "mistralai/devstral-medium", maxOutputTokens: 24e3 }
+};
+function getMaxOutputTokens(model) {
+  const byKey = MODEL_PRESETS[model];
+  if (byKey) return byKey.maxOutputTokens;
+  const byModel = Object.values(MODEL_PRESETS).find((p) => p.model === model);
+  return byModel?.maxOutputTokens ?? 8192;
+}
+
+// src/arena/render/terminal.ts
+init_esm_shims();
+import chalk from "chalk";
+function formatArenaResult(result) {
+  const modeLabel = result.mode.charAt(0).toUpperCase() + result.mode.slice(1);
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold(`  \u2550\u2550\u2550 ${modeLabel} Conclusion \u2550\u2550\u2550`));
+  lines.push("");
+  if (result.consensus.summary) {
+    lines.push(`  ${result.consensus.summary}`);
+    lines.push("");
+  }
+  if (result.mode === "planning") {
+    lines.push(...formatRoadmapSection(result.consensus.roadmap));
+    if (result.consensus.roadmapDetails && result.consensus.roadmapDetails.length > 0) {
+      lines.push(...formatRoadmapDetailsSection(result.consensus.roadmapDetails));
+    }
+  }
+  for (const section of getOrderedConsensusSections(result)) {
+    lines.push(...formatConsensusSection(section.title, section.items, section.color, section.icon));
+  }
+  if (result.mode !== "planning") {
+    lines.push(...formatRoadmapSection(result.consensus.roadmap));
+  }
+  if (result.consensus.nextActions.length > 0) {
+    lines.push(chalk.bold.white("\n  Next Actions:"));
+    for (const action of result.consensus.nextActions) {
+      const pri = action.priority === "high" ? chalk.red("HIGH") : action.priority === "medium" ? chalk.yellow("MED") : chalk.dim("LOW");
+      lines.push(`    ${chalk.white("\u2192")} [${pri}${chalk.white("]")} ${action.title}`);
+      if (action.rationale) {
+        lines.push(chalk.dim(`      ${action.rationale}`));
+      }
+    }
+  }
+  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(chalk.dim(
+    `  Mode: ${modeLabel} | Findings: ${countFindings(result)} | Models: ${result.participants.join(", ")}` + planInfo
+  ));
+  lines.push("");
+  return lines.join("\n");
+}
+function printArenaResult(result) {
+  console.log(formatArenaResult(result));
+}
+function formatConsensusSection(title, items, color, icon) {
+  if (items.length === 0) return [];
+  const lines = [];
+  lines.push(color(`
+  ${title}:`));
+  for (const item of items) {
+    lines.push(color(`    ${icon} ${item.title}`));
+    if (item.summary) {
+      lines.push(chalk.dim(`      ${item.summary}`));
+    }
+    if (item.challenge.length > 0) {
+      lines.push(chalk.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) {
+  if (phases.length === 0) return [];
+  const lines = [];
+  lines.push(chalk.bold.white("\n  Roadmap:"));
+  for (const [index, phase] of phases.entries()) {
+    const pri = phase.priority === "high" ? chalk.red("HIGH") : phase.priority === "medium" ? chalk.yellow("MED") : chalk.dim("LOW");
+    lines.push(`    ${chalk.white("\u2192")} Phase ${index + 1}: ${phase.title} [${pri}${chalk.white("]")}`);
+    if (phase.goal) {
+      lines.push(chalk.dim(`      Goal: ${phase.goal}`));
+    }
+    if (phase.scope.length > 0) {
+      lines.push(chalk.dim(`      Scope: ${phase.scope.join("; ")}`));
+    }
+    if (phase.deliverables.length > 0) {
+      lines.push(chalk.dim(`      Deliverables: ${phase.deliverables.join("; ")}`));
+    }
+    if (phase.dependencies.length > 0) {
+      lines.push(chalk.dim(`      Dependencies: ${phase.dependencies.join("; ")}`));
+    }
+    if (phase.risks.length > 0) {
+      lines.push(chalk.dim(`      Risks: ${phase.risks.join("; ")}`));
+    }
+    if (phase.successCriteria.length > 0) {
+      lines.push(chalk.dim(`      Success: ${phase.successCriteria.join("; ")}`));
+    }
+  }
+  return lines;
+}
+function formatRoadmapDetailsSection(details) {
+  const lines = [];
+  lines.push(chalk.bold.white("\n  Implementation Details:"));
+  for (const detail of details) {
+    const effort = detail.effort === "large" ? chalk.red("L") : detail.effort === "medium" ? chalk.yellow("M") : chalk.green("S");
+    lines.push(`
+    ${chalk.white("\u25B8")} ${detail.phaseTitle} [${effort}]`);
+    if (detail.objective) {
+      lines.push(chalk.dim(`      ${detail.objective}`));
+    }
+    if (detail.targetFiles.length > 0) {
+      lines.push(chalk.dim(`      Files: ${detail.targetFiles.join(", ")}`));
+    }
+    if (detail.codeChanges.length > 0) {
+      for (const change of detail.codeChanges) {
+        lines.push(chalk.dim(`      \u2022 ${change}`));
+      }
+    }
+    if (detail.interfaces.length > 0) {
+      lines.push(chalk.dim(`      Interfaces: ${detail.interfaces.join("; ")}`));
+    }
+    if (detail.migrationSteps.length > 0) {
+      lines.push(chalk.dim(`      Migration:`));
+      for (const [i, step] of detail.migrationSteps.entries()) {
+        lines.push(chalk.dim(`        ${i + 1}. ${step}`));
+      }
+    }
+    if (detail.validation.length > 0) {
+      lines.push(chalk.dim(`      Validation: ${detail.validation.join("; ")}`));
+    }
+    if (detail.blockers.length > 0) {
+      lines.push(chalk.red(`      Blockers: ${detail.blockers.join("; ")}`));
+    }
+  }
+  return lines;
+}
+function getOrderedConsensusSections(result) {
+  const VALID_KINDS = /* @__PURE__ */ 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: chalk.green, icon: "\u2713" };
+      case "improvement":
+        return { kind, title: "Improvements", items: result.consensus.improvements, color: chalk.yellow, icon: "\u2192" };
+      case "risk":
+        return { kind, title: "Risks", items: result.consensus.risks, color: chalk.red, icon: "\u26A0" };
+      case "question":
+        return { kind, title: "Open Questions", items: result.consensus.openQuestions, color: chalk.cyan, icon: "?" };
+    }
+  }).filter((section) => section != null).filter((section) => section.items.length > 0);
+}
+function dedupeFindingKinds(kinds) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const kind of kinds) {
+    if (!seen.has(kind)) {
+      seen.add(kind);
+      result.push(kind);
+    }
+  }
+  return result;
+}
+function createProgressRenderer(sink) {
+  return (event) => {
+    switch (event.type) {
+      case "plan_resolved":
+        sink(chalk.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_collected":
+        sink(chalk.dim(`Evidence: ${event.artifacts.length} artifacts collected`));
+        break;
+      case "research_start":
+        sink(chalk.dim(`\u23F3 ${event.participant} researching...`));
+        break;
+      case "research_done": {
+        const fCount = event.report.findings.length;
+        sink(`${event.participant}: ${chalk.green("done")} (${fCount} findings)`);
+        break;
+      }
+      case "context_lookup":
+        for (const t of event.tools) {
+          sink(chalk.dim(`  \u{1F50D} ${event.participant}: ${t}`));
+        }
+        break;
+      case "claims_registered":
+        sink(chalk.dim(`${event.claimCount} claims registered`));
+        break;
+      case "cross_review_start":
+        sink(chalk.dim("\u2500\u2500 Cross Review \u2500\u2500"));
+        break;
+      case "cross_review_done":
+        sink(chalk.dim(`${event.reviews.length} peer reviews collected`));
+        break;
+      case "verification_start":
+        sink(chalk.dim("\u2500\u2500 Verification Review \u2500\u2500"));
+        break;
+      case "verification_done":
+        sink(chalk.dim(`${event.challengeCount} challenges raised`));
+        break;
+      case "debate_round_start":
+        sink(chalk.dim(`\u2500\u2500 Debate Round ${event.round} (${event.claims.length} claims) \u2500\u2500`));
+        break;
+      case "debate_round_done":
+        sink(chalk.dim(`Round ${event.round}: ${event.resolved} resolved`));
+        break;
+      case "adjudication_done":
+        sink(chalk.dim(`Adjudication: ${event.accepted} accepted, ${event.unresolved} unresolved`));
+        break;
+      case "planning_merge_review_start":
+        sink(chalk.dim("\u2500\u2500 Planning Merge Review \u2500\u2500"));
+        break;
+      case "planning_merge_review_done":
+        sink(chalk.dim(`${event.mergeCount} merge suggestions collected`));
+        break;
+      case "roadmap_expansion_start":
+        sink(chalk.dim(`\u2500\u2500 Expanding ${event.phaseCount} roadmap phases \u2500\u2500`));
+        break;
+      case "roadmap_expansion_done":
+        sink(chalk.dim(`${event.detailCount} phase details generated`));
+        break;
+      case "consensus_start":
+        sink(chalk.dim("\u23F3 Building consensus..."));
+        break;
+      case "consensus_done":
+        break;
+    }
+  };
+}
+function renderProgress(event) {
+  createProgressRenderer((text) => console.log(`  ${text}`))(event);
+}
+
+// src/arena/render/session.ts
+init_esm_shims();
+function formatArenaResultForSession(result) {
+  const lines = [];
+  const modeLabel = result.mode.charAt(0).toUpperCase() + result.mode.slice(1);
+  lines.push(`## Arena ${modeLabel} Result`);
+  lines.push(`**Topic:** ${result.topic}`);
+  lines.push(`**Models:** ${result.participants.join(" vs ")}`);
+  lines.push("");
+  const c = result.consensus;
+  if (c.subjectSummary) {
+    const overviewLabel = result.plan.outputShape.overviewLabel ?? (result.mode === "review" ? "What Changed" : result.mode === "planning" ? "Current Scope" : "Problem Framing");
+    lines.push(`### ${overviewLabel}`);
+    lines.push(c.subjectSummary);
+    lines.push("");
+  }
+  if (c.summary) {
+    lines.push("### Overall Assessment");
+    lines.push(c.summary);
+    lines.push("");
+  }
+  if (result.mode === "planning" && c.roadmap.length > 0) {
+    lines.push("### Roadmap");
+    for (const [index, phase] of c.roadmap.entries()) {
+      lines.push(...formatRoadmapPhase(index, phase));
+    }
+    lines.push("");
+    if (c.roadmapDetails && c.roadmapDetails.length > 0) {
+      lines.push("### Implementation Details");
+      for (const detail of c.roadmapDetails) {
+        lines.push(...formatPhaseDetail(detail));
+      }
+      lines.push("");
+    }
+  }
+  for (const section of getOrderedConsensusSections2(result)) {
+    lines.push(`### ${section.title}`);
+    for (const item of section.items) {
+      lines.push(`- **${item.title}**: ${item.summary}`);
+    }
+    lines.push("");
+  }
+  if (result.mode !== "planning" && c.roadmap.length > 0) {
+    lines.push("### Roadmap");
+    for (const [index, phase] of c.roadmap.entries()) {
+      lines.push(...formatRoadmapPhase(index, phase));
+    }
+    lines.push("");
+  }
+  if (c.nextActions.length > 0) {
+    lines.push("### Next Actions");
+    for (const action of c.nextActions) {
+      const pri = action.priority === "high" ? "\u{1F534}" : action.priority === "medium" ? "\u{1F7E1}" : "\u26AA";
+      lines.push(`- ${pri} **${action.title}**: ${action.rationale}`);
+    }
+    lines.push("");
+  }
+  if (result.reports.some((r) => r.findings.length > 0)) {
+    lines.push("---");
+    lines.push("### Participant Findings");
+    for (const report of result.reports) {
+      if (report.findings.length === 0) {
+        lines.push(`
+**${report.participant}**: ${report.contextSummary || "(no findings)"}`);
+        continue;
+      }
+      lines.push(`
+**${report.participant}** (${report.findings.length} findings)`);
+      if (report.contextSummary) {
+        lines.push(`> ${report.contextSummary}`);
+      }
+      for (const f of report.findings) {
+        const severity = f.severity ? `/${f.severity}` : "";
+        lines.push(`- [${f.kind}${severity}] **${f.title}**: ${f.summary}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatRoadmapPhase(index, phase) {
+  const pri = phase.priority === "high" ? "High" : phase.priority === "medium" ? "Medium" : "Low";
+  const lines = [`#### Phase ${index + 1}: ${phase.title} (${pri} priority)`];
+  if (phase.goal) {
+    lines.push(`Goal: ${phase.goal}`);
+  }
+  if (phase.scope.length > 0) {
+    lines.push(`Scope: ${phase.scope.join("; ")}`);
+  }
+  if (phase.deliverables.length > 0) {
+    lines.push(`Deliverables: ${phase.deliverables.join("; ")}`);
+  }
+  if (phase.dependencies.length > 0) {
+    lines.push(`Dependencies: ${phase.dependencies.join("; ")}`);
+  }
+  if (phase.risks.length > 0) {
+    lines.push(`Risks: ${phase.risks.join("; ")}`);
+  }
+  if (phase.successCriteria.length > 0) {
+    lines.push(`Success Criteria: ${phase.successCriteria.join("; ")}`);
+  }
+  lines.push("");
+  return lines;
+}
+function formatPhaseDetail(detail) {
+  const effort = detail.effort === "large" ? "Large" : detail.effort === "small" ? "Small" : "Medium";
+  const lines = [`#### ${detail.phaseTitle} (${effort} effort)`];
+  if (detail.objective) {
+    lines.push(detail.objective);
+  }
+  if (detail.targetFiles.length > 0) {
+    lines.push(`**Target files:** ${detail.targetFiles.map((f) => "`" + f + "`").join(", ")}`);
+  }
+  if (detail.codeChanges.length > 0) {
+    lines.push("**Code changes:**");
+    for (const change of detail.codeChanges) {
+      lines.push(`- ${change}`);
+    }
+  }
+  if (detail.interfaces.length > 0) {
+    lines.push(`**Interfaces:** ${detail.interfaces.join("; ")}`);
+  }
+  if (detail.migrationSteps.length > 0) {
+    lines.push("**Migration steps:**");
+    for (const [i, step] of detail.migrationSteps.entries()) {
+      lines.push(`${i + 1}. ${step}`);
+    }
+  }
+  if (detail.validation.length > 0) {
+    lines.push(`**Validation:** ${detail.validation.join("; ")}`);
+  }
+  if (detail.blockers.length > 0) {
+    lines.push(`**Blockers:** ${detail.blockers.join("; ")}`);
+  }
+  lines.push("");
+  return lines;
+}
+function getOrderedConsensusSections2(result) {
+  const VALID_KINDS = /* @__PURE__ */ 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 = dedupeFindingKinds2([...emphasize, ...defaultOrder]);
+  const sections = orderedKinds.map((kind) => {
+    switch (kind) {
+      case "strength":
+        return { kind, title: "\u2713 Strengths", items: result.consensus.strengths };
+      case "improvement":
+        return { kind, title: "\u2192 Improvements", items: result.consensus.improvements };
+      case "risk":
+        return { kind, title: "\u26A0 Risks", items: result.consensus.risks };
+      case "question":
+        return { kind, title: "? Open Questions", items: result.consensus.openQuestions };
+    }
+  });
+  return sections.filter((section) => section != null).filter((section) => section.items.length > 0);
+}
+function dedupeFindingKinds2(kinds) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const kind of kinds) {
+    if (!seen.has(kind)) {
+      seen.add(kind);
+      result.push(kind);
+    }
+  }
+  return result;
+}
+
+export {
+  registerProvider,
+  createLLMClient,
+  isStrategyV2,
+  ReviewStrategy,
+  DiscussionStrategy,
+  PlanningStrategy,
+  getLens,
+  resolveLenses,
+  buildLensPrompt,
+  LENS_NAMES,
+  getStrategy,
+  getStrategyForPlan,
+  planArena,
+  collectEvidence,
+  selectTools,
+  hasTools,
+  runParticipantResearch,
+  runParticipantResearchWithDossiers,
+  registerClaims,
+  selectClaimsForReview,
+  buildDigest,
+  formatDigest,
+  transitionClaim,
+  resolveClaimStatus,
+  markUnderReview,
+  applyReviewResult,
+  markUnresolved,
+  isTerminal,
+  validTransitions,
+  runCrossReview,
+  runVerificationReview,
+  runDebateRounds,
+  runAdjudication,
+  buildConsensus,
+  ArenaLedger,
+  Arena,
+  MODEL_PRESETS,
+  getMaxOutputTokens,
+  formatArenaResult,
+  printArenaResult,
+  createProgressRenderer,
+  renderProgress,
+  formatArenaResultForSession
+};