@cjhyy/code-shell-core 0.7.1 → 0.8.1

package/dist/arena/strategies/lens-wrapper.js

@@ -1,236 +0,0 @@
-/**
- * Lens-aware strategy wrapper.
- *
- * Composes a mode strategy with lens-specific prompts:
- *   systemPrompt = modeStrategy.systemPrompt() + lensPrompt + toolGuidance
- *
- * This achieves the separation described in the architecture doc:
- * - Strategy (mode) → how to collaborate
- * - Lens → from what perspective
- */
-import { isStrategyV2, isStrategyPlanning } from "../types.js";
-import { resolveLenses, buildLensPrompt } from "../lenses/index.js";
-/**
- * Wrap a strategy to inject lens-specific role and criteria prompts.
- * If no plan is provided, returns the original strategy unchanged.
- */
-export 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),
-                "",
-                "── Analysis Perspective ──",
-                participantLensPrompt,
-                "",
-                "── Scenario Support ──",
-                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),
-                "",
-                "── Review Perspective ──",
-                reviewerLensPrompt,
-                "",
-                "── Scenario Support ──",
-                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(),
-                "",
-                "── Moderator Perspective ──",
-                moderatorLensPrompt,
-                "",
-                "── Scenario Support ──",
-                moderatorPlanPrompt,
-            ].join("\n");
-        },
-        consensusUserPrompt(topic, reports, reviews) {
-            return [formatPlanBrief(plan), "", strategy.consensusUserPrompt(topic, reports, reviews)].join("\n");
-        },
-        parseConsensusResponse(text) {
-            return strategy.parseConsensusResponse(text);
-        },
-        preferredFindingKinds() {
-            // Merge mode + lens preferred kinds, deduplicated
-            const modeKinds = strategy.preferredFindingKinds();
-            const lensKinds = lenses.flatMap((l) => l.preferredFindingKinds);
-            const planKinds = plan.outputShape.emphasize;
-            const seen = 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(),
-                    "",
-                    "── Moderator Perspective ──",
-                    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} — ${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} — ${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(", ") : "";
-}

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

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

package/dist/arena/strategies/planning.js

@@ -1,225 +0,0 @@
-/**
- * Planning strategy — collaborative roadmap building with structured findings.
- *
- * V2: focuses on implementation phases, dependencies, risks, and open questions.
- */
-import { formatBaseContext, formatReports, formatFindingReviews, formatClaimsForReview, formatDebateHistory, formatClaimSummaryForConsensus, formatDigestForPrompt, parseReport, parseReviews, parseConsensus, parseChallenges, parseDebateTurn, parseAdjudication, parseDetailExpansion, } from "./utils.js";
-export class PlanningStrategy {
-    researchSystemPrompt(name) {
-        return (`You are ${name}, a planner in a multi-model planning session.\n\n` +
-            `You may have access to read-only tools to investigate the subject. ` +
-            `The base context is intentionally lean — use tools as needed.\n\n` +
-            `IMPORTANT RULES:\n` +
-            `- Limit yourself to 3-5 tool rounds. Do NOT exhaustively read every file.\n` +
-            `- Output as many findings as the topic warrants — typically 5-15 for a non-trivial subject. ` +
-            `Each finding's "summary" should be 80+ words with concrete evidence and rationale, not a one-liner. ` +
-            `Rank by confidence.\n` +
-            `- Focus on: implementation phases (improvement), risks/blockers, decisions needed (question).\n` +
-            `- Strengths are optional.\n\n` +
-            `Respond ONLY with JSON (no markdown fences):\n` +
-            `{"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\n${topic}\n\n` +
-            `${formatBaseContext(baseContext)}\n\n` +
-            `Use tools to investigate, then output 3-6 highest-confidence findings as JSON.`);
-    }
-    parseResearchResponse(participant, text) {
-        return parseReport(participant, text);
-    }
-    crossReviewSystemPrompt(reviewerName) {
-        return (`You are ${reviewerName}, reviewing other architects' planning proposals.\n\n` +
-            `Evaluate critically: identify gaps, suggest improvements, propose better alternatives.\n\n` +
-            `For each finding you want to address:\n` +
-            `- "agree": the proposed phase/risk is valid\n` +
-            `- "refine": adjust scope, priority, or dependencies\n` +
-            `- "disagree": propose a different approach\n` +
-            `- "needs_evidence": more investigation needed\n\n` +
-            `Respond ONLY with a JSON array:\n` +
-            `[{"findingId": "...", "verdict": "...", "reason": "...", "extraEvidence": ["optional"]}]`);
-    }
-    crossReviewUserPrompt(topic, myReport, otherReports) {
-        return (`## Topic: ${topic}\n\n` +
-            `## Your Proposed Plan\n${formatReports([myReport])}\n\n` +
-            `## Other Architects' Plans\n${formatReports(otherReports)}\n\n` +
-            `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.\n\n` +
-            `Combine the best ideas into a unified plan with clear sequencing, priorities, and delivery phases.\n` +
-            `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.\n\n` +
-            `Respond ONLY with JSON (no markdown fences):\n` +
-            `{\n` +
-            `  "summary": "unified plan overview",\n` +
-            `  "subjectSummary": "factual overview of the current repo/problem scope before proposing changes",\n` +
-            `  "strengths": [{"title": "...", "summary": "...", "support": [], "challenge": [], "confidence": 0.0-1.0, "evidenceRefs": []}],\n` +
-            `  "improvements": [implementation phases as consensus items],\n` +
-            `  "risks": [identified risks],\n` +
-            `  "openQuestions": [decisions needed],\n` +
-            `  "roadmap": [{"title": "...", "priority": "high|medium|low", "goal": "...", "scope": ["..."], "deliverables": ["..."], "dependencies": ["..."], "risks": ["..."], "successCriteria": ["..."], "relatedFindings": []}],\n` +
-            `  "nextActions": [{"title": "...", "priority": "high|medium|low", "rationale": "...", "relatedFindings": []}]\n` +
-            `}`);
-    }
-    consensusUserPrompt(topic, reports, reviews) {
-        return (`## Topic\n${topic}\n\n` +
-            `## Proposed Plans\n${formatReports(reports)}\n\n` +
-            `## Peer Reviews\n${formatFindingReviews(reviews)}\n\n` +
-            `Synthesize a final implementation roadmap.\n` +
-            `Requirements:\n` +
-            `- Start with a factual subjectSummary of the current scope.\n` +
-            `- Produce 3 to 6 roadmap phases covering sequencing, dependencies, deliverables, and success criteria.\n` +
-            `- 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}\n\n` +
-            `## Your Proposed Plan\n${formatReports([myReport])}\n\n` +
-            `## Claims to Verify\n${formatClaimsForReview(claimsToReview)}\n\n` +
-            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
-            `Evaluate each claim for feasibility, sequencing, and dependencies. Challenge proposals that lack evidence.\n` +
-            `Respond ONLY with a JSON array:\n` +
-            `[{"claimId": "...", "verdict": "agree|refine|disagree|needs_evidence", "reason": "...", ` +
-            `"supportingEvidenceRefs": ["optional"], "requestedChecks": [{"description": "what to check", "priority": "high|medium|low"}]}]`);
-    }
-    parseVerificationReviewResponse(reviewer, text) {
-        return parseChallenges(reviewer, text);
-    }
-    // ─── V2: Debate ─────────────────────────────────────────────────
-    debateTurnUserPrompt(topic, claim, priorTurns, digest) {
-        return (`## Topic: ${topic}\n\n` +
-            `## Contested Planning Proposal\n` +
-            `[${claim.claimId}] ${claim.finding.title}\n${claim.finding.summary}\n\n` +
-            `## Prior Debate\n${formatDebateHistory(priorTurns)}\n\n` +
-            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
-            `Argue for or against this proposal. Focus on feasibility, risks, and better alternatives.\n` +
-            `Respond ONLY with JSON:\n` +
-            `{"stance": "support|oppose|narrow|uncertain", "summary": "your argument", "newEvidenceRefs": ["optional"]}`);
-    }
-    parseDebateTurnResponse(participant, text) {
-        return parseDebateTurn(participant, text);
-    }
-    // ─── V2: Adjudication ──────────────────────────────────────────
-    adjudicationUserPrompt(topic, claim, debateRounds, digest) {
-        const debateSummary = debateRounds.length > 0
-            ? debateRounds.map((r) => `Round ${r.round}:\n${formatDebateHistory(r.participants)}\n${r.resolved ? "→ Resolved" : "→ Unresolved"}`).join("\n\n")
-            : "No debate rounds occurred.";
-        return (`## Topic: ${topic}\n\n` +
-            `## Contested Proposal\n` +
-            `[${claim.claimId}] ${claim.finding.title}\n${claim.finding.summary}\n` +
-            `Owner: ${claim.owner}\n\n` +
-            `## Challenges\n` +
-            claim.challenges.map((c) => `[${c.reviewer}] ${c.verdict}: ${c.reason}`).join("\n") + "\n\n" +
-            `## Debate\n${debateSummary}\n\n` +
-            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
-            `As moderator, decide whether this proposal should be included in the final plan.\n` +
-            `Respond ONLY with JSON:\n` +
-            `{"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}\n\n` +
-            `## Your Proposed Plan\n${formatReports([myReport])}\n\n` +
-            `## Candidate Claims (Proposed Phases & Findings)\n${formatClaimsForReview(claimsToReview)}\n\n` +
-            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
-            `You are reviewing planning proposals for MERGE and CONVERGENCE, not for correctness judging.\n\n` +
-            `For each claim, decide how it should be incorporated into the final roadmap:\n` +
-            `- "agree": the proposed phase/finding is valid as-is\n` +
-            `- "refine": merge with another phase, adjust priority/scope/dependencies, or narrow scope\n` +
-            `- "disagree": only for proposals that directly contradict repo evidence\n` +
-            `- "needs_evidence": mark as open question for further investigation\n\n` +
-            `In your reason, use these semantic tags where applicable:\n` +
-            `[merge] — combine with another phase\n` +
-            `[reprioritize] — change priority ordering\n` +
-            `[split_phase] — break into smaller phases\n` +
-            `[combine_phase] — merge multiple phases into one\n` +
-            `[dependency_risk] — flag missing dependency\n` +
-            `[needs_detail] — needs more implementation specifics\n` +
-            `[open_question] — convert to open question\n\n` +
-            `Respond ONLY with a JSON array:\n` +
-            `[{"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.\n\n` +
-            `You may have access to read-only tools to investigate the codebase. Use them to verify file paths, interfaces, and module boundaries.\n\n` +
-            `IMPORTANT RULES:\n` +
-            `- Be specific: name actual files, modules, interfaces, and functions.\n` +
-            `- If you're uncertain about a target, write "likely: <path>" and note the uncertainty.\n` +
-            `- Do not produce vague platitudes like "refactor the module" — say what changes.\n` +
-            `- Limit tool usage to 2-3 rounds for verification.\n\n` +
-            `Respond ONLY with JSON (no markdown fences):\n` +
-            `{"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\n${topic}\n\n` +
-            `## Roadmap Phase to Expand\n${phaseContext}\n\n` +
-            `## Evidence Digest\n${formatDigestForPrompt(digest)}\n\n` +
-            `Expand this phase into a repo-level implementation plan.\n` +
-            `Use tools to verify file paths and interfaces if available.\n` +
-            `Answer these questions:\n` +
-            `1. Which files/modules need to change?\n` +
-            `2. What are the specific code changes?\n` +
-            `3. What interfaces need to be added or modified?\n` +
-            `4. What are the migration steps (in order)?\n` +
-            `5. How do we validate the changes?\n` +
-            `6. What is the effort estimate?\n` +
-            `7. What are the blockers?`);
-    }
-    parseDetailExpansionResponse(text) {
-        return parseDetailExpansion(text);
-    }
-    // ─── V2: Claim-Aware Consensus ─────────────────────────────────
-    claimAwareConsensusUserPrompt(topic, reports, reviews, claimSummary) {
-        return (`## Topic\n${topic}\n\n` +
-            `## Claim Verification Status\n${formatClaimSummaryForConsensus(claimSummary)}\n\n` +
-            `## Proposed Plans\n${formatReports(reports)}\n\n` +
-            `## Peer Reviews\n${formatFindingReviews(reviews)}\n\n` +
-            `Synthesize a final implementation roadmap.\n` +
-            `Requirements:\n` +
-            `- Verified claims should form the backbone of the roadmap.\n` +
-            `- Unresolved claims should appear as open questions or conditional phases.\n` +
-            `- Produce 3 to 6 roadmap phases with sequencing, dependencies, deliverables, and success criteria.\n` +
-            `- Use nextActions only for immediate follow-up work.`);
-    }
-}

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

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