@llm-jury/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./calibration/index.ts";
+export * from "./classifiers/index.ts";
+export * from "./debate/index.ts";
+export * from "./judges/index.ts";
+export * from "./jury/index.ts";
+export * from "./llm/index.ts";
+export * from "./personas/index.ts";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./calibration/index.js";
+export * from "./classifiers/index.js";
+export * from "./debate/index.js";
+export * from "./judges/index.js";
+export * from "./jury/index.js";
+export * from "./llm/index.js";
+export * from "./personas/index.js";

package/dist/judges/base.d.ts

@@ -0,0 +1,16 @@
+import type { ClassificationResult } from "../classifiers/base.ts";
+import type { DebateTranscript } from "../debate/engine.ts";
+export type Verdict = {
+    label: string;
+    confidence: number;
+    reasoning: string;
+    wasEscalated: boolean;
+    primaryResult: ClassificationResult;
+    debateTranscript: DebateTranscript | null;
+    judgeStrategy: string;
+    totalDurationMs: number;
+    totalCostUsd: number | null;
+};
+export interface JudgeStrategy {
+    judge(transcript: DebateTranscript, labels: string[]): Promise<Verdict>;
+}

package/dist/judges/base.js

@@ -0,0 +1 @@
+export {};

package/dist/judges/bayesian.d.ts

@@ -0,0 +1,8 @@
+import type { DebateTranscript } from "../debate/engine.ts";
+import type { JudgeStrategy, Verdict } from "./base.ts";
+export type PersonaPriors = Record<string, Record<string, number>>;
+export declare class BayesianJudge implements JudgeStrategy {
+    private priors;
+    constructor(priors?: PersonaPriors);
+    judge(transcript: DebateTranscript, labels: string[]): Promise<Verdict>;
+}

package/dist/judges/bayesian.js

@@ -0,0 +1,52 @@
+export class BayesianJudge {
+    priors;
+    constructor(priors = {}) {
+        this.priors = priors;
+    }
+    async judge(transcript, labels) {
+        const finalRound = transcript.rounds[transcript.rounds.length - 1] ?? [];
+        if (finalRound.length === 0) {
+            return {
+                label: transcript.primaryResult.label,
+                confidence: transcript.primaryResult.confidence,
+                reasoning: "No persona responses available. Falling back to primary result.",
+                wasEscalated: true,
+                primaryResult: transcript.primaryResult,
+                debateTranscript: transcript,
+                judgeStrategy: "bayesian",
+                totalDurationMs: transcript.durationMs,
+                totalCostUsd: transcript.totalCostUsd,
+            };
+        }
+        const posterior = new Map();
+        labels.forEach((label) => posterior.set(label, 1));
+        for (const response of finalRound) {
+            for (const label of labels) {
+                const prior = this.priors[response.personaName]?.[label] ?? 1 / Math.max(1, labels.length);
+                const likelihood = response.label === label ? Number(response.confidence) : 1 - Number(response.confidence);
+                posterior.set(label, (posterior.get(label) ?? 1) * Math.max(1e-6, prior * likelihood));
+            }
+        }
+        const sum = Array.from(posterior.values()).reduce((a, b) => a + b, 0) || 1;
+        let winner = labels[0] ?? transcript.primaryResult.label;
+        let winnerScore = -1;
+        for (const [label, score] of posterior.entries()) {
+            const normalized = score / sum;
+            if (normalized > winnerScore) {
+                winner = label;
+                winnerScore = normalized;
+            }
+        }
+        return {
+            label: winner,
+            confidence: winnerScore,
+            reasoning: "Bayesian aggregation across persona responses.",
+            wasEscalated: true,
+            primaryResult: transcript.primaryResult,
+            debateTranscript: transcript,
+            judgeStrategy: "bayesian",
+            totalDurationMs: transcript.durationMs,
+            totalCostUsd: transcript.totalCostUsd,
+        };
+    }
+}

package/dist/judges/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./base.ts";
+export * from "./bayesian.ts";
+export * from "./llmJudge.ts";
+export * from "./majorityVote.ts";
+export * from "./weightedVote.ts";

package/dist/judges/index.js

@@ -0,0 +1,5 @@
+export * from "./base.js";
+export * from "./bayesian.js";
+export * from "./llmJudge.js";
+export * from "./majorityVote.js";
+export * from "./weightedVote.js";

package/dist/judges/llmJudge.d.ts

@@ -0,0 +1,19 @@
+import type { LLMClient } from "../llm/client.ts";
+import type { DebateTranscript } from "../debate/engine.ts";
+import type { JudgeStrategy, Verdict } from "./base.ts";
+export type LLMJudgeOptions = {
+    model?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    llmClient?: LLMClient;
+};
+export declare class LLMJudge implements JudgeStrategy {
+    static readonly DEFAULT_SYSTEM_PROMPT: string;
+    private model;
+    private systemPrompt;
+    private temperature;
+    private llmClient;
+    constructor(options?: LLMJudgeOptions);
+    judge(transcript: DebateTranscript, labels: string[]): Promise<Verdict>;
+    buildPrompt(transcript: DebateTranscript, labels: string[]): string;
+}

package/dist/judges/llmJudge.js

@@ -0,0 +1,86 @@
+import { LiteLLMClient } from "../llm/client.js";
+import { stripMarkdown, safeJsonObject } from "../utils.js";
+export class LLMJudge {
+    static DEFAULT_SYSTEM_PROMPT = "You are the presiding judge in an expert panel. " +
+        "You have received assessments from multiple domain experts on a classification task.\n\n" +
+        "Your role is to:\n" +
+        "1. Weigh each expert's reasoning on its merits\n" +
+        "2. Consider the strength of evidence each expert cites\n" +
+        "3. Note where experts agree and disagree\n" +
+        "4. Factor in each expert's known perspective/bias\n" +
+        "5. If a debate summary is provided, use it to identify the decisive arguments\n" +
+        "6. Deliver a final classification with clear reasoning\n\n" +
+        "Respond ONLY with valid JSON:\n" +
+        "{\n" +
+        '  "label": "<final classification>",\n' +
+        '  "confidence": <0.0-1.0>,\n' +
+        '  "reasoning": "<your synthesis of the debate>",\n' +
+        '  "key_agreements": ["<points all experts agreed on>"],\n' +
+        '  "key_disagreements": ["<points of contention>"],\n' +
+        '  "decisive_factor": "<what tipped the decision>"\n' +
+        "}";
+    model;
+    systemPrompt;
+    temperature;
+    llmClient;
+    constructor(options = {}) {
+        this.model = options.model ?? "gpt-5-mini";
+        this.systemPrompt = options.systemPrompt ?? LLMJudge.DEFAULT_SYSTEM_PROMPT;
+        this.temperature = options.temperature ?? 0;
+        this.llmClient = options.llmClient ?? new LiteLLMClient();
+    }
+    async judge(transcript, labels) {
+        const prompt = this.buildPrompt(transcript, labels);
+        const payload = await this.llmClient.complete(this.model, this.systemPrompt, prompt, this.temperature);
+        const parsed = safeJsonObject(stripMarkdown(payload.content));
+        if (!parsed) {
+            return {
+                label: String(transcript.primaryResult.label),
+                confidence: Number(transcript.primaryResult.confidence),
+                reasoning: "LLM judge response was not valid JSON. Falling back to primary result.",
+                wasEscalated: true,
+                primaryResult: transcript.primaryResult,
+                debateTranscript: transcript,
+                judgeStrategy: "llm_judge_fallback_invalid_json",
+                totalDurationMs: transcript.durationMs,
+                totalCostUsd: Number(transcript.totalCostUsd ?? 0) + Number(payload.costUsd ?? 0),
+            };
+        }
+        return {
+            label: String(parsed.label ?? transcript.primaryResult.label),
+            confidence: Number(parsed.confidence ?? transcript.primaryResult.confidence),
+            reasoning: String(parsed.reasoning ?? "LLM judge response."),
+            wasEscalated: true,
+            primaryResult: transcript.primaryResult,
+            debateTranscript: transcript,
+            judgeStrategy: "llm_judge",
+            totalDurationMs: transcript.durationMs,
+            totalCostUsd: Number(transcript.totalCostUsd ?? 0) + Number(payload.costUsd ?? 0),
+        };
+    }
+    buildPrompt(transcript, labels) {
+        const lines = [];
+        lines.push(`Input: ${transcript.inputText}`);
+        lines.push(`Available labels: ${labels.join(", ")}`);
+        lines.push(`Primary result: ${transcript.primaryResult.label} (${Number(transcript.primaryResult.confidence).toFixed(2)})`);
+        lines.push("Debate transcript:");
+        transcript.rounds.forEach((round, index) => {
+            if (index === 0) {
+                lines.push("Initial Expert Opinions:");
+            }
+            else {
+                lines.push(`Revised Opinions (Round ${index + 1}):`);
+            }
+            round.forEach((response) => {
+                lines.push(`- ${response.personaName}: ${response.label} (${Number(response.confidence).toFixed(2)}) | Reasoning: ${response.reasoning}`);
+            });
+        });
+        if (transcript.summary) {
+            lines.push("");
+            lines.push("Debate Summary:");
+            lines.push(transcript.summary);
+        }
+        lines.push("Respond ONLY with JSON containing: label, confidence, reasoning, key_agreements, key_disagreements, decisive_factor.");
+        return lines.join("\n");
+    }
+}

package/dist/judges/majorityVote.d.ts

@@ -0,0 +1,5 @@
+import type { DebateTranscript } from "../debate/engine.ts";
+import type { JudgeStrategy, Verdict } from "./base.ts";
+export declare class MajorityVoteJudge implements JudgeStrategy {
+    judge(transcript: DebateTranscript, _labels: string[]): Promise<Verdict>;
+}

package/dist/judges/majorityVote.js

@@ -0,0 +1,45 @@
+export class MajorityVoteJudge {
+    async judge(transcript, _labels) {
+        const finalRound = transcript.rounds[transcript.rounds.length - 1] ?? [];
+        if (finalRound.length === 0) {
+            return {
+                label: transcript.primaryResult.label,
+                confidence: transcript.primaryResult.confidence,
+                reasoning: "No persona responses available. Falling back to primary result.",
+                wasEscalated: true,
+                primaryResult: transcript.primaryResult,
+                debateTranscript: transcript,
+                judgeStrategy: "majority_vote",
+                totalDurationMs: transcript.durationMs,
+                totalCostUsd: transcript.totalCostUsd,
+            };
+        }
+        const counts = new Map();
+        for (const response of finalRound) {
+            counts.set(response.label, (counts.get(response.label) ?? 0) + 1);
+        }
+        let winner = "";
+        let winnerCount = -1;
+        for (const [label, count] of counts.entries()) {
+            if (count > winnerCount) {
+                winner = label;
+                winnerCount = count;
+            }
+        }
+        const reasoning = finalRound
+            .filter((response) => response.label === winner)
+            .map((response) => response.reasoning)
+            .join(" ");
+        return {
+            label: winner,
+            confidence: winnerCount / finalRound.length,
+            reasoning: reasoning || "Majority vote selected the winner.",
+            wasEscalated: true,
+            primaryResult: transcript.primaryResult,
+            debateTranscript: transcript,
+            judgeStrategy: "majority_vote",
+            totalDurationMs: transcript.durationMs,
+            totalCostUsd: transcript.totalCostUsd,
+        };
+    }
+}

package/dist/judges/weightedVote.d.ts

@@ -0,0 +1,5 @@
+import type { DebateTranscript } from "../debate/engine.ts";
+import type { JudgeStrategy, Verdict } from "./base.ts";
+export declare class WeightedVoteJudge implements JudgeStrategy {
+    judge(transcript: DebateTranscript, _labels: string[]): Promise<Verdict>;
+}

package/dist/judges/weightedVote.js

@@ -0,0 +1,42 @@
+export class WeightedVoteJudge {
+    async judge(transcript, _labels) {
+        const finalRound = transcript.rounds[transcript.rounds.length - 1] ?? [];
+        if (finalRound.length === 0) {
+            return {
+                label: transcript.primaryResult.label,
+                confidence: transcript.primaryResult.confidence,
+                reasoning: "No persona responses available. Falling back to primary result.",
+                wasEscalated: true,
+                primaryResult: transcript.primaryResult,
+                debateTranscript: transcript,
+                judgeStrategy: "weighted_vote",
+                totalDurationMs: transcript.durationMs,
+                totalCostUsd: transcript.totalCostUsd,
+            };
+        }
+        const scores = new Map();
+        for (const response of finalRound) {
+            scores.set(response.label, (scores.get(response.label) ?? 0) + Number(response.confidence));
+        }
+        let winner = "";
+        let bestScore = -1;
+        for (const [label, score] of scores.entries()) {
+            if (score > bestScore) {
+                winner = label;
+                bestScore = score;
+            }
+        }
+        const total = Array.from(scores.values()).reduce((a, b) => a + b, 0) || 1;
+        return {
+            label: winner,
+            confidence: bestScore / total,
+            reasoning: "Weighted vote based on persona confidence scores.",
+            wasEscalated: true,
+            primaryResult: transcript.primaryResult,
+            debateTranscript: transcript,
+            judgeStrategy: "weighted_vote",
+            totalDurationMs: transcript.durationMs,
+            totalCostUsd: transcript.totalCostUsd,
+        };
+    }
+}

package/dist/jury/core.d.ts

@@ -0,0 +1,43 @@
+import type { ClassificationResult, Classifier } from "../classifiers/base.ts";
+import { DebateConfig, DebateEngine } from "../debate/engine.ts";
+import type { LLMClient } from "../llm/client.ts";
+import type { Persona } from "../personas/base.ts";
+import type { JudgeStrategy, Verdict } from "../judges/base.ts";
+export type JuryOptions = {
+    classifier: Classifier;
+    personas: Persona[];
+    confidenceThreshold?: number;
+    debateConcurrency?: number;
+    judge?: JudgeStrategy;
+    debateConfig?: DebateConfig;
+    escalationOverride?: (result: ClassificationResult) => boolean;
+    maxDebateCostUsd?: number;
+    onEscalation?: (text: string, result: ClassificationResult) => void;
+    onVerdict?: (verdict: Verdict) => void;
+    llmClient?: LLMClient;
+};
+export declare class JuryStats {
+    total: number;
+    fastPath: number;
+    escalated: number;
+    get escalationRate(): number;
+    get costSavingsVsAlwaysEscalate(): number;
+}
+export declare class Jury {
+    classifier: Classifier;
+    personas: Persona[];
+    threshold: number;
+    judge: JudgeStrategy;
+    debateConfig: DebateConfig;
+    debateEngine: DebateEngine;
+    escalationOverride?: (result: ClassificationResult) => boolean;
+    maxDebateCostUsd?: number;
+    onEscalation?: (text: string, result: ClassificationResult) => void;
+    onVerdict?: (verdict: Verdict) => void;
+    private _stats;
+    constructor(options: JuryOptions);
+    classify(text: string): Promise<Verdict>;
+    classifyBatch(texts: string[], concurrency?: number): Promise<Verdict[]>;
+    shouldEscalate(result: ClassificationResult): boolean;
+    get stats(): JuryStats;
+}

package/dist/jury/core.js

@@ -0,0 +1,113 @@
+import { DebateConfig, DebateEngine } from "../debate/engine.js";
+import { LiteLLMClient } from "../llm/client.js";
+import { LLMJudge } from "../judges/llmJudge.js";
+export class JuryStats {
+    total = 0;
+    fastPath = 0;
+    escalated = 0;
+    get escalationRate() {
+        return this.total > 0 ? this.escalated / this.total : 0;
+    }
+    get costSavingsVsAlwaysEscalate() {
+        return this.total > 0 ? this.fastPath / this.total : 0;
+    }
+}
+export class Jury {
+    classifier;
+    personas;
+    threshold;
+    judge;
+    debateConfig;
+    debateEngine;
+    escalationOverride;
+    maxDebateCostUsd;
+    onEscalation;
+    onVerdict;
+    _stats;
+    constructor(options) {
+        this.classifier = options.classifier;
+        this.personas = options.personas;
+        this.threshold = options.confidenceThreshold ?? 0.7;
+        const llmClient = options.llmClient ?? new LiteLLMClient();
+        this.judge = options.judge ?? new LLMJudge({ llmClient });
+        this.debateConfig = options.debateConfig ?? new DebateConfig();
+        this.debateEngine = new DebateEngine(this.personas, this.debateConfig, llmClient, Math.max(1, options.debateConcurrency ?? 5));
+        this.escalationOverride = options.escalationOverride;
+        this.maxDebateCostUsd = options.maxDebateCostUsd;
+        this.onEscalation = options.onEscalation;
+        this.onVerdict = options.onVerdict;
+        this._stats = new JuryStats();
+    }
+    async classify(text) {
+        const start = Date.now();
+        const primary = await this.classifier.classify(text);
+        this._stats.total += 1;
+        const shouldEscalate = this.shouldEscalate(primary) && this.personas.length > 0;
+        if (!shouldEscalate) {
+            this._stats.fastPath += 1;
+            return {
+                label: primary.label,
+                confidence: primary.confidence,
+                reasoning: "Classified by primary classifier with sufficient confidence.",
+                wasEscalated: false,
+                primaryResult: primary,
+                debateTranscript: null,
+                judgeStrategy: "primary_classifier",
+                totalDurationMs: Date.now() - start,
+                totalCostUsd: 0,
+            };
+        }
+        this._stats.escalated += 1;
+        this.onEscalation?.(text, primary);
+        const transcript = await this.debateEngine.debate(text, primary, this.classifier.labels, this.maxDebateCostUsd ?? null);
+        if (this.maxDebateCostUsd != null && transcript.totalCostUsd != null && transcript.totalCostUsd > this.maxDebateCostUsd) {
+            return {
+                label: primary.label,
+                confidence: primary.confidence,
+                reasoning: "Debate exceeded maxDebateCostUsd. Returning primary classifier result.",
+                wasEscalated: true,
+                primaryResult: primary,
+                debateTranscript: transcript,
+                judgeStrategy: "cost_guard_primary_fallback",
+                totalDurationMs: Date.now() - start,
+                totalCostUsd: transcript.totalCostUsd,
+            };
+        }
+        const verdict = await this.judge.judge(transcript, this.classifier.labels);
+        verdict.wasEscalated = true;
+        verdict.primaryResult = primary;
+        verdict.debateTranscript = transcript;
+        verdict.totalDurationMs = Date.now() - start;
+        if (verdict.totalCostUsd == null) {
+            verdict.totalCostUsd = transcript.totalCostUsd;
+        }
+        this.onVerdict?.(verdict);
+        return verdict;
+    }
+    async classifyBatch(texts, concurrency = 10) {
+        const limit = Math.max(1, concurrency);
+        const results = new Array(texts.length);
+        let cursor = 0;
+        const workers = new Array(Math.min(limit, texts.length)).fill(null).map(async () => {
+            while (true) {
+                const index = cursor;
+                cursor += 1;
+                if (index >= texts.length) {
+                    break;
+                }
+                results[index] = await this.classify(texts[index]);
+            }
+        });
+        await Promise.all(workers);
+        return results;
+    }
+    shouldEscalate(result) {
+        if (this.escalationOverride) {
+            return Boolean(this.escalationOverride(result));
+        }
+        return result.confidence < this.threshold;
+    }
+    get stats() {
+        return this._stats;
+    }
+}

package/dist/jury/index.d.ts

@@ -0,0 +1 @@
+export * from "./core.ts";

package/dist/jury/index.js

@@ -0,0 +1 @@
+export * from "./core.js";

package/dist/llm/client.d.ts

@@ -0,0 +1,23 @@
+export interface LLMClient {
+    complete(model: string, systemPrompt: string, prompt: string, temperature?: number): Promise<{
+        content: string;
+        tokens?: number;
+        costUsd?: number;
+    }>;
+}
+export type LiteLLMClientOptions = {
+    baseUrl?: string;
+    apiKey?: string;
+    timeoutMs?: number;
+};
+export declare class LiteLLMClient implements LLMClient {
+    private baseUrl;
+    private apiKey;
+    private timeoutMs;
+    constructor(options?: LiteLLMClientOptions);
+    complete(model: string, systemPrompt: string, prompt: string, temperature?: number): Promise<{
+        content: string;
+        tokens?: number;
+        costUsd?: number;
+    }>;
+}

package/dist/llm/client.js

@@ -0,0 +1,85 @@
+async function withRetry(fn, maxAttempts = 3, baseDelayMs = 1000) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            const isTransient = err instanceof TypeError ||
+                (err instanceof Error && err.name === "AbortError") ||
+                (err instanceof Error && /5\d{2}|429/.test(err.message));
+            if (!isTransient || attempt === maxAttempts) {
+                throw err;
+            }
+            const delay = baseDelayMs * Math.pow(2, attempt - 1);
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    throw lastError;
+}
+export class LiteLLMClient {
+    baseUrl;
+    apiKey;
+    timeoutMs;
+    constructor(options = {}) {
+        this.baseUrl = (options.baseUrl ?? process.env.LITELLM_BASE_URL ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1").replace(/\/$/, "");
+        this.apiKey = options.apiKey ?? process.env.LITELLM_API_KEY ?? process.env.OPENAI_API_KEY ?? null;
+        this.timeoutMs = options.timeoutMs ?? 60000;
+    }
+    async complete(model, systemPrompt, prompt, temperature = 0) {
+        if (!this.apiKey) {
+            throw new Error("No API key configured. Set LITELLM_API_KEY or OPENAI_API_KEY, or inject a custom llmClient.");
+        }
+        const body = {
+            model,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: prompt },
+            ],
+        };
+        if (shouldSendTemperature(model, temperature)) {
+            body.temperature = temperature;
+        }
+        return withRetry(async () => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+            try {
+                const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const detail = await response.text();
+                    throw new Error(`LLM request failed (${response.status}): ${detail}`);
+                }
+                const payload = (await response.json());
+                const content = payload.choices?.[0]?.message?.content;
+                if (typeof content !== "string") {
+                    throw new Error("LLM response did not include choices[0].message.content");
+                }
+                return {
+                    content,
+                    tokens: Number(payload.usage?.total_tokens ?? 0),
+                    costUsd: undefined,
+                };
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        });
+    }
+}
+function shouldSendTemperature(model, temperature) {
+    if (typeof temperature !== "number" || Number.isNaN(temperature)) {
+        return false;
+    }
+    const lower = model.toLowerCase();
+    const noTempPrefixes = ["o1", "o3", "gpt-5"];
+    return !noTempPrefixes.some((prefix) => lower.startsWith(prefix));
+}

package/dist/llm/index.d.ts

@@ -0,0 +1 @@
+export * from "./client.ts";

package/dist/llm/index.js

@@ -0,0 +1 @@
+export * from "./client.js";

package/dist/personas/base.d.ts

@@ -0,0 +1,19 @@
+export type Persona = {
+    name: string;
+    role: string;
+    systemPrompt: string;
+    model: string;
+    temperature: number;
+    knownBias?: string;
+};
+export type PersonaResponse = {
+    personaName: string;
+    label: string;
+    confidence: number;
+    reasoning: string;
+    keyFactors: string[];
+    dissentNotes?: string;
+    rawResponse?: string;
+    tokensUsed?: number;
+    costUsd?: number;
+};

package/dist/personas/base.js

@@ -0,0 +1 @@
+export {};

package/dist/personas/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./base.ts";
+export * from "./registry.ts";

package/dist/personas/index.js

@@ -0,0 +1,2 @@
+export * from "./base.js";
+export * from "./registry.js";

package/dist/personas/registry.d.ts

@@ -0,0 +1,8 @@
+import type { Persona } from "./base.ts";
+export declare class PersonaRegistry {
+    static contentModeration(): Persona[];
+    static legalCompliance(): Persona[];
+    static medicalTriage(): Persona[];
+    static financialCompliance(): Persona[];
+    static custom(personas: Persona[]): Persona[];
+}