@cjhyy/code-shell-arena 0.8.0

package/dist/iterate/phases/tournament.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Tournament v1 phase — every participant writes a candidate, then the
+ * author merges anonymized candidates into v1.
+ */
+import type { ArenaParticipant } from "../../types.js";
+import type { FormatPack } from "../formats/index.js";
+import type { Draft, DraftCandidate, IterateProgressEvent, IterateSubject } from "../types.js";
+/** Run the v1 tournament: parallel candidate generation. */
+export declare function runTournamentCandidates(args: {
+    subject: IterateSubject;
+    format: FormatPack;
+    participants: ArenaParticipant[];
+    minDraftLength: number;
+    signal?: AbortSignal;
+    onProgress?: (e: IterateProgressEvent) => void;
+}): Promise<DraftCandidate[]>;
+/** Merge candidates into v1 using the author. */
+export declare function mergeCandidatesToV1(args: {
+    subject: IterateSubject;
+    format: FormatPack;
+    author: ArenaParticipant;
+    candidates: DraftCandidate[];
+    minDraftLength: number;
+    signal?: AbortSignal;
+    onProgress?: (e: IterateProgressEvent) => void;
+}): Promise<Draft>;
+/** Single-author v1 (tournament disabled) — author writes alone. */
+export declare function singleAuthorV1(args: {
+    subject: IterateSubject;
+    format: FormatPack;
+    author: ArenaParticipant;
+    minDraftLength: number;
+    signal?: AbortSignal;
+}): Promise<Draft>;

package/dist/iterate/phases/tournament.js

@@ -0,0 +1,113 @@
+/**
+ * Tournament v1 phase — every participant writes a candidate, then the
+ * author merges anonymized candidates into v1.
+ */
+import { createLLMClient } from "@cjhyy/code-shell-core/extension";
+import { logger } from "@cjhyy/code-shell-core/extension";
+import { parseMergeResponse } from "../parse.js";
+/** Run the v1 tournament: parallel candidate generation. */
+export async function runTournamentCandidates(args) {
+    const { subject, format, participants, minDraftLength, signal, onProgress } = args;
+    onProgress?.({ type: "v1_tournament_start", data: { count: participants.length } });
+    const tasks = participants.map(async (p, idx) => {
+        signal?.throwIfAborted();
+        const client = await createLLMClient(p.llm, p.clientDefaults);
+        const prompt = format.draftPrompt(subject, minDraftLength);
+        // Long-form generation needs a high output ceiling; the default 8k from
+        // LLMClientBase is too low for a substantive PRD or design doc and
+        // results in mid-sentence truncation that breaks downstream parsing.
+        const resp = await client.createMessage({
+            systemPrompt: prompt,
+            messages: [{ role: "user", content: `Write your draft now.` }],
+            tools: [],
+            maxTokens: 32_000,
+            signal,
+        });
+        const content = resp.text.trim();
+        const candidate = {
+            author: p.name,
+            anonymousLabel: `Draft ${String.fromCharCode(65 + idx)}`, // A, B, C...
+            content,
+        };
+        onProgress?.({
+            type: "v1_candidate_done",
+            participant: p.name,
+            data: { length: content.length, anonymousLabel: candidate.anonymousLabel },
+        });
+        logger.info("arena.iterate.v1_candidate", {
+            participant: p.name,
+            anonymousLabel: candidate.anonymousLabel,
+            length: content.length,
+        });
+        return candidate;
+    });
+    // Tolerate individual failures — we'd rather merge fewer drafts than abort.
+    const settled = await Promise.allSettled(tasks);
+    const candidates = [];
+    for (const s of settled) {
+        if (s.status === "fulfilled")
+            candidates.push(s.value);
+        else
+            logger.warn("arena.iterate.v1_candidate_failed", { error: s.reason?.message });
+    }
+    if (candidates.length === 0) {
+        throw new Error("All v1 tournament candidates failed");
+    }
+    // Shuffle so anonymous labels don't correlate with participants[] order.
+    for (let i = candidates.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [candidates[i], candidates[j]] = [candidates[j], candidates[i]];
+        candidates[i].anonymousLabel = `Draft ${String.fromCharCode(65 + i)}`;
+    }
+    candidates[0].anonymousLabel = `Draft A`;
+    return candidates;
+}
+/** Merge candidates into v1 using the author. */
+export async function mergeCandidatesToV1(args) {
+    const { subject, format, author, candidates, minDraftLength, signal, onProgress } = args;
+    onProgress?.({ type: "v1_merge_start", participant: author.name });
+    const client = await createLLMClient(author.llm, author.clientDefaults);
+    const prompt = format.mergePrompt(subject, candidates, minDraftLength);
+    const resp = await client.createMessage({
+        systemPrompt: prompt,
+        messages: [{ role: "user", content: `Produce v1 now.` }],
+        tools: [],
+        maxTokens: 32_000,
+        signal,
+    });
+    const { content, rationale } = parseMergeResponse(resp.text);
+    const draft = {
+        version: 1,
+        author: author.name,
+        format: format.format,
+        content,
+        draftCandidates: candidates,
+        mergeRationale: rationale,
+    };
+    onProgress?.({ type: "v1_merge_done", participant: author.name, data: { length: content.length } });
+    logger.info("arena.iterate.v1_merge", {
+        author: author.name,
+        candidateCount: candidates.length,
+        length: content.length,
+    });
+    return draft;
+}
+/** Single-author v1 (tournament disabled) — author writes alone. */
+export async function singleAuthorV1(args) {
+    const { subject, format, author, minDraftLength, signal } = args;
+    const client = await createLLMClient(author.llm, author.clientDefaults);
+    const prompt = format.draftPrompt(subject, minDraftLength);
+    const resp = await client.createMessage({
+        systemPrompt: prompt,
+        messages: [{ role: "user", content: `Write your draft now.` }],
+        tools: [],
+        maxTokens: 32_000,
+        signal,
+    });
+    return {
+        version: 1,
+        author: author.name,
+        format: format.format,
+        content: resp.text.trim(),
+    };
+}

package/dist/iterate/tools/web-tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Web tools for arena iterate critics — fabrication detection support.
+ *
+ * Wraps the existing builtin webSearchTool / webFetchTool so critics can
+ * verify factual claims during the argue phase.
+ */
+import type { ToolDefinition } from "@cjhyy/code-shell-core/extension";
+export declare const webSearchToolDef: ToolDefinition;
+export declare const webFetchToolDef: ToolDefinition;
+export declare const ITERATE_WEB_TOOLS: ToolDefinition[];
+export declare function executeIterateWebTool(toolName: string, args: Record<string, unknown>): Promise<string>;
+/** Probe env to determine if any web-search provider is configured. */
+export declare function hasWebSearchProvider(): boolean;

package/dist/iterate/tools/web-tools.js

@@ -0,0 +1,54 @@
+/**
+ * Web tools for arena iterate critics — fabrication detection support.
+ *
+ * Wraps the existing builtin webSearchTool / webFetchTool so critics can
+ * verify factual claims during the argue phase.
+ */
+import { webSearchTool } from "@cjhyy/code-shell-core/extension";
+import { webFetchTool } from "@cjhyy/code-shell-core/extension";
+export const webSearchToolDef = {
+    name: "web_search",
+    description: "Search the web (Google via Serper / Tavily / SearXNG depending on env). " +
+        "Use this to verify any specific number, citation, URL, library version, " +
+        "API name, or external claim made in the draft you are reviewing. " +
+        "If a claim cannot be verified by web_search, mark it as a fabrication " +
+        "critique with severity = blocker.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Search query (English usually works best)." },
+            num_results: { type: "number", description: "Default 5, max 20." },
+        },
+        required: ["query"],
+    },
+};
+export const webFetchToolDef = {
+    name: "web_fetch",
+    description: "Fetch a URL and return its text content (HTML stripped). Use after " +
+        "web_search to read the actual page content of a search result and " +
+        "confirm a specific claim, version number, or quoted figure.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "Full http(s) URL to fetch." },
+            max_length: { type: "number", description: "Default 50000 characters." },
+        },
+        required: ["url"],
+    },
+};
+export const ITERATE_WEB_TOOLS = [webSearchToolDef, webFetchToolDef];
+export async function executeIterateWebTool(toolName, args) {
+    if (toolName === "web_search") {
+        return webSearchTool(args);
+    }
+    if (toolName === "web_fetch") {
+        return webFetchTool(args);
+    }
+    return `Error: unknown tool "${toolName}"`;
+}
+/** Probe env to determine if any web-search provider is configured. */
+export function hasWebSearchProvider() {
+    return Boolean(process.env.SERPER_API_KEY ||
+        process.env.TAVILY_API_KEY ||
+        process.env.SEARXNG_URL);
+}

package/dist/iterate/types.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Iterate mode — multi-model authoring loop.
+ *
+ * Author writes → critics argue → author revises → ... → final draft.
+ * v1 uses a tournament: every participant writes a candidate, then the
+ * author merges (anonymized inputs) into a single v1.
+ */
+import type { ArenaParticipant } from "../types.js";
+export type IterateFormat = "code" | "document";
+export interface IterateSubject {
+    /** What the author is producing — short descriptive label. */
+    label: string;
+    /** Full instruction to the author / critics. */
+    description: string;
+    /** Optional source artifacts (file paths, urls) to ground the work. */
+    sources?: string[];
+}
+/** A v1 candidate produced by one participant during the tournament. */
+export interface DraftCandidate {
+    author: string;
+    anonymousLabel: string;
+    content: string;
+}
+export interface Draft {
+    version: number;
+    author: string;
+    format: IterateFormat;
+    content: string;
+    /**
+     * For v1 with tournament strategy: the candidates that were merged.
+     * For v2+: undefined.
+     */
+    draftCandidates?: DraftCandidate[];
+    /** Author's explanation of how candidates were merged into v1. */
+    mergeRationale?: string;
+    /**
+     * For v2+: which critique IDs were addressed and how.
+     */
+    acceptedCritiques?: string[];
+    rejectedCritiques?: Array<{
+        id: string;
+        reason: string;
+    }>;
+    /** Free-form note from author: what changed and why. */
+    changelog?: string;
+}
+export type CritiqueSeverity = "blocker" | "major" | "minor" | "nit" | "praise";
+export type CritiqueCategory = "correctness" | "completeness" | "clarity" | "evidence" | "structure" | "style" | "fabrication" | "other";
+export interface CritiqueEvidence {
+    url: string;
+    snippet?: string;
+}
+export interface Critique {
+    id: string;
+    critic: string;
+    /** 5-15 word quote from the draft for precise location. */
+    anchor: string;
+    severity: CritiqueSeverity;
+    category: CritiqueCategory;
+    comment: string;
+    /** Optional concrete suggestion. */
+    suggestion?: string;
+    /** Optional URLs the critic consulted to back up the critique. */
+    evidence?: CritiqueEvidence[];
+}
+export interface ConvergenceSignal {
+    blockerCount: number;
+    majorCount: number;
+    totalCritiques: number;
+    /** Levenshtein-ratio-like 0..1, where 0 = identical, 1 = totally different. */
+    diffFromPrevious: number;
+    shouldStop: boolean;
+    reason: "blockers_zero_and_stable" | "all_minor_or_praise" | "max_rounds" | "user_stop" | "user_force_continue" | "diff_below_threshold" | "running";
+}
+export interface Round {
+    round: number;
+    draft: Draft;
+    critiques: Critique[];
+    convergence: ConvergenceSignal;
+}
+export type AuthorRotation = "fixed" | "round-robin" | "best-critic";
+export interface CheckpointContext {
+    round: number;
+    draft: Draft;
+    critiques: Critique[];
+    convergence: ConvergenceSignal;
+}
+export type CheckpointAction = "continue" | "stop" | "force-continue";
+export type CheckpointFn = (ctx: CheckpointContext) => Promise<CheckpointAction>;
+export interface IterateProgressEvent {
+    type: "v1_tournament_start" | "v1_candidate_done" | "v1_merge_start" | "v1_merge_done" | "round_start" | "argue_start" | "argue_done" | "revise_start" | "revise_done" | "round_done" | "checkpoint_pause" | "iterate_complete";
+    round?: number;
+    participant?: string;
+    data?: Record<string, unknown>;
+}
+export interface IterateConfig {
+    subject: IterateSubject;
+    format: IterateFormat;
+    /** The participant who merges v1 and main-authors v2+. Required. */
+    author: ArenaParticipant;
+    /** Critic participants. Each must have unique `name`. */
+    critics: ArenaParticipant[];
+    /** Default 5. */
+    maxRounds?: number;
+    /**
+     * v1 strategy.
+     * - "tournament" (default): author + all critics each write a candidate,
+     *    author merges anonymized candidates into v1.
+     * - "single": author writes v1 alone (no tournament).
+     */
+    v1Strategy?: "tournament" | "single";
+    /** Default "fixed". */
+    authorRotation?: AuthorRotation;
+    /**
+     * If provided, called after each round; arena pauses for the response.
+     * Default: undefined (no checkpoints).
+     */
+    humanCheckpoint?: CheckpointFn;
+    /**
+     * Convergence rules. "default" applies built-in heuristics.
+     * Custom function returns true → stop after this round.
+     */
+    convergenceStrategy?: "default" | ((ctx: {
+        round: number;
+        critiques: Critique[];
+        draft: Draft;
+        previousDraft?: Draft;
+    }) => boolean);
+    /** Minimum content length per draft (chars). Used both as length budget hint and to retry-on-shrinkage. Default 800 for document, 200 for code. */
+    minDraftLength?: number;
+    /**
+     * Whether critics get web_search/web_fetch tools during the argue phase.
+     * Requires SERPER_API_KEY / TAVILY_API_KEY / SEARXNG_URL in env. Default false.
+     * When true, each argue call becomes a tool-use loop (critics may search
+     * before producing critiques) — significantly more tokens and time, but
+     * dramatically reduces fabrication.
+     */
+    enableWebSearch?: boolean;
+    /** Cap tool-use rounds per critic per argue phase. Default 8. */
+    maxArgueToolRounds?: number;
+    signal?: AbortSignal;
+    onProgress?: (event: IterateProgressEvent) => void;
+}
+export type StoppedReason = "converged" | "max_rounds" | "user_stop" | "errored" | "aborted";
+export interface IterateResult {
+    subject: IterateSubject;
+    format: IterateFormat;
+    rounds: Round[];
+    finalDraft: Draft;
+    stoppedAt: StoppedReason;
+    durationMs: number;
+}

package/dist/iterate/types.js

@@ -0,0 +1,8 @@
+/**
+ * Iterate mode — multi-model authoring loop.
+ *
+ * Author writes → critics argue → author revises → ... → final draft.
+ * v1 uses a tournament: every participant writes a candidate, then the
+ * author merges (anonymized inputs) into a single v1.
+ */
+export {};

package/dist/ledger.d.ts

@@ -0,0 +1,47 @@
+/**
+ * SharedResearchLedger — append-only shared state across all arena rounds.
+ *
+ * Design constraints (from architecture doc):
+ * - All objects have stable IDs
+ * - Append-only: history preserved, never overwritten
+ * - Query layer supports latest-view aggregation
+ * - Supports by-id, by-claim, by-participant, by-round filtering
+ */
+import type { SharedResearchLedger, ResearchDossier, EvidencePacket, ClaimRecord, ClaimChallenge, RequestedCheck, ClaimAdjudication } from "./types.js";
+/**
+ * Manages the shared research ledger — the single source of truth
+ * for all evidence, claims, challenges, and adjudications in an arena session.
+ */
+export declare class ArenaLedger {
+    private ledger;
+    private index;
+    constructor();
+    /** Check if ledger is approaching memory limits and log warnings */
+    private checkGrowth;
+    appendDossier(dossier: ResearchDossier): void;
+    appendEvidencePacket(packet: EvidencePacket): void;
+    appendClaim(claim: ClaimRecord): void;
+    appendChallenge(challenge: ClaimChallenge): void;
+    appendRequestedCheck(check: RequestedCheck): void;
+    appendAdjudication(adjudication: ClaimAdjudication): void;
+    /**
+     * 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(): Readonly<SharedResearchLedger>;
+    getClaimById(claimId: string): ClaimRecord | undefined;
+    getPacketById(packetId: string): EvidencePacket | undefined;
+    getAllClaims(): ClaimRecord[];
+    getClaimsByStatus(...statuses: ClaimRecord["status"][]): ClaimRecord[];
+    getClaimsByOwner(owner: string): ClaimRecord[];
+    getChallengesForClaim(claimId: string): ClaimChallenge[];
+    getPendingChecks(): RequestedCheck[];
+    getPendingChecksForClaim(claimId: string): RequestedCheck[];
+    getPacketsForClaim(claimId: string): EvidencePacket[];
+    getDossiers(): ResearchDossier[];
+    getDossierByParticipant(participant: string): ResearchDossier | undefined;
+}

package/dist/ledger.js

@@ -0,0 +1,159 @@
+/**
+ * SharedResearchLedger — append-only shared state across all arena rounds.
+ *
+ * Design constraints (from architecture doc):
+ * - All objects have stable IDs
+ * - Append-only: history preserved, never overwritten
+ * - Query layer supports latest-view aggregation
+ * - Supports by-id, by-claim, by-participant, by-round filtering
+ */
+import { logger } from "@cjhyy/code-shell-core/extension";
+/** Thresholds for memory warnings */
+const WARN_CLAIMS = 50;
+const WARN_PACKETS = 200;
+const WARN_CHALLENGES = 100;
+/**
+ * Manages the shared research ledger — the single source of truth
+ * for all evidence, claims, challenges, and adjudications in an arena session.
+ */
+export class ArenaLedger {
+    ledger;
+    index;
+    constructor() {
+        this.ledger = {
+            dossiers: [],
+            evidencePackets: [],
+            toolTraces: [],
+            claims: [],
+            challenges: [],
+            requestedChecks: [],
+            adjudications: [],
+        };
+        this.index = {
+            claimsById: new Map(),
+            packetsById: new Map(),
+            requestsById: 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) {
+        // Deduplicate by packetId — reuse existing if same ID
+        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);
+        // Also add to the claim's challenges array. If the claimId doesn't resolve
+        // the challenge still lives in ledger.challenges but is invisible to any
+        // code reading claim.challenges directly — surface that inconsistency.
+        const claim = this.index.claimsById.get(challenge.claimId);
+        if (claim) {
+            claim.challenges.push(challenge);
+        }
+        else {
+            logger.warn("arena.challenge_for_unknown_claim", { claimId: challenge.claimId });
+        }
+        this.checkGrowth();
+        // Register any requested checks
+        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);
+        // Also attach to the claim
+        const claim = this.index.claimsById.get(adjudication.claimId);
+        if (claim) {
+            claim.adjudication = adjudication;
+        }
+        else {
+            logger.warn("arena.adjudication_for_unknown_claim", { claimId: adjudication.claimId });
+        }
+    }
+    // ─── 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 !== undefined);
+    }
+    getDossiers() {
+        return this.ledger.dossiers;
+    }
+    getDossierByParticipant(participant) {
+        // Return the latest dossier for this participant (supports multi-round)
+        const dossiers = this.ledger.dossiers.filter((d) => d.participant === participant);
+        return dossiers[dossiers.length - 1];
+    }
+}

package/dist/lenses/architecture.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Architecture lens — system boundaries, modularity, evolution path.
+ */
+import type { ArenaLens } from "../types.js";
+export declare const architectureLens: ArenaLens;

package/dist/lenses/architecture.js

@@ -0,0 +1,22 @@
+/**
+ * Architecture lens — system boundaries, modularity, evolution path.
+ */
+export const 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"],
+};

package/dist/lenses/engineering.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Engineering lens — code quality, correctness, performance, maintainability.
+ */
+import type { ArenaLens } from "../types.js";
+export declare const engineeringLens: ArenaLens;

package/dist/lenses/engineering.js

@@ -0,0 +1,22 @@
+/**
+ * Engineering lens — code quality, correctness, performance, maintainability.
+ */
+export const 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"],
+};

package/dist/lenses/general.d.ts

@@ -0,0 +1,5 @@
+/**
+ * General lens — broad analysis without a specific domain focus.
+ */
+import type { ArenaLens } from "../types.js";
+export declare const generalLens: ArenaLens;

package/dist/lenses/general.js

@@ -0,0 +1,20 @@
+/**
+ * General lens — broad analysis without a specific domain focus.
+ */
+export const 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"],
+};