@llm-jury/core 0.1.0

package/dist/classifiers/sklearnAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { ClassificationResult, Classifier } from "./base.ts";
+export type SklearnLikeModel = {
+    predictProba(features: unknown): number[][] | Promise<number[][]>;
+};
+export type VectorizerLike = {
+    transform(texts: string[]): unknown;
+};
+export declare class SklearnClassifier implements Classifier {
+    labels: string[];
+    private model;
+    private vectorizer?;
+    constructor(model: SklearnLikeModel, labels: string[], vectorizer?: VectorizerLike);
+    classify(text: string): Promise<ClassificationResult>;
+}

package/dist/classifiers/sklearnAdapter.js

@@ -0,0 +1,29 @@
+export class SklearnClassifier {
+    labels;
+    model;
+    vectorizer;
+    constructor(model, labels, vectorizer) {
+        this.model = model;
+        this.labels = labels;
+        this.vectorizer = vectorizer;
+    }
+    async classify(text) {
+        const features = this.vectorizer ? this.vectorizer.transform([text]) : [text];
+        const probabilities = await this.model.predictProba(features);
+        const row = probabilities[0] ?? [];
+        if (row.length === 0) {
+            throw new Error("predictProba returned no probabilities for input");
+        }
+        let bestIndex = 0;
+        for (let i = 1; i < row.length; i += 1) {
+            if (row[i] > row[bestIndex]) {
+                bestIndex = i;
+            }
+        }
+        return {
+            label: this.labels[bestIndex] ?? String(bestIndex),
+            confidence: Number(row[bestIndex] ?? 0),
+            rawOutput: row,
+        };
+    }
+}

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

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

package/dist/cli/main.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare function parseLabels(raw: string | null, fallback?: string[]): string[];
+export declare function resolveCalibrationLabels(rawLabels: string | null, expectedLabels: string[]): string[];
+export declare function main(argv?: string[]): Promise<number>;

package/dist/cli/main.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import { ThresholdCalibrator } from "../calibration/optimizer.js";
+import { FunctionClassifier } from "../classifiers/functionAdapter.js";
+import { HuggingFaceClassifier } from "../classifiers/huggingFaceAdapter.js";
+import { LLMClassifier } from "../classifiers/llmClassifier.js";
+import { DebateConfig, DebateMode } from "../debate/engine.js";
+import { BayesianJudge } from "../judges/bayesian.js";
+import { LLMJudge } from "../judges/llmJudge.js";
+import { MajorityVoteJudge } from "../judges/majorityVote.js";
+import { WeightedVoteJudge } from "../judges/weightedVote.js";
+import { Jury } from "../jury/core.js";
+import { PersonaRegistry } from "../personas/registry.js";
+function parseArg(argv, name) {
+    const idx = argv.indexOf(name);
+    if (idx === -1 || idx + 1 >= argv.length) {
+        return null;
+    }
+    return argv[idx + 1] ?? null;
+}
+function parseBoolFlag(argv, name) {
+    return argv.includes(name);
+}
+function readJsonl(path) {
+    const lines = readFileSync(path, "utf8")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return lines.map((line) => JSON.parse(line));
+}
+function writeJsonl(path, rows) {
+    writeFileSync(path, rows.map((row) => JSON.stringify(row)).join("\n") + "\n", "utf8");
+}
+function toSnakeCaseObject(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => toSnakeCaseObject(item));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const snake = key.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`);
+            out[snake] = toSnakeCaseObject(entry);
+        }
+        return out;
+    }
+    return value;
+}
+export function parseLabels(raw, fallback = ["safe", "unsafe"]) {
+    if (!raw) {
+        return fallback;
+    }
+    const labels = raw
+        .split(",")
+        .map((label) => label.trim())
+        .filter(Boolean);
+    return labels.length > 0 ? labels : fallback;
+}
+export function resolveCalibrationLabels(rawLabels, expectedLabels) {
+    return parseLabels(rawLabels, Array.from(new Set(expectedLabels)));
+}
+function selectPersonas(name) {
+    switch (name.toLowerCase()) {
+        case "content_moderation":
+            return PersonaRegistry.contentModeration();
+        case "legal_compliance":
+            return PersonaRegistry.legalCompliance();
+        case "medical_triage":
+            return PersonaRegistry.medicalTriage();
+        case "financial_compliance":
+            return PersonaRegistry.financialCompliance();
+        default:
+            throw new Error(`Unsupported personas set: ${name}`);
+    }
+}
+function applyPersonaModel(personas, model) {
+    if (!model) {
+        return personas;
+    }
+    return personas.map((persona) => ({ ...persona, model }));
+}
+function selectJudge(name, model) {
+    switch (name.toLowerCase()) {
+        case "llm":
+            return new LLMJudge({ model: model ?? "gpt-5-mini" });
+        case "majority":
+            return new MajorityVoteJudge();
+        case "weighted":
+            return new WeightedVoteJudge();
+        case "bayesian":
+            return new BayesianJudge();
+        default:
+            throw new Error(`Unsupported judge strategy: ${name}`);
+    }
+}
+function buildDebateConfig(argv) {
+    const rawMode = parseArg(argv, "--debate-mode") ?? DebateMode.INDEPENDENT;
+    const modeValues = Object.values(DebateMode);
+    if (!modeValues.includes(rawMode)) {
+        throw new Error(`Unsupported debate mode: ${rawMode}`);
+    }
+    const maxRounds = Number(parseArg(argv, "--max-rounds") ?? "1");
+    return new DebateConfig({
+        mode: rawMode,
+        maxRounds,
+        includePrimaryResult: !parseBoolFlag(argv, "--hide-primary-result"),
+        includeConfidence: !parseBoolFlag(argv, "--hide-confidence"),
+    });
+}
+function buildClassifier(classifierSpec, labels, rows) {
+    if (classifierSpec === "function") {
+        const predictionMap = new Map();
+        rows.forEach((row, idx) => {
+            const text = String(row.text ?? `row-${idx}`);
+            const predictedLabel = String(row.predicted_label ?? row.label ?? labels[0] ?? "unknown");
+            const predictedConfidence = Number(row.predicted_confidence ?? 0.95);
+            predictionMap.set(text, [predictedLabel, predictedConfidence]);
+        });
+        return {
+            classifier: new FunctionClassifier((text) => predictionMap.get(text) ?? [labels[0] ?? "unknown", 0.95], labels),
+            isMockClassifier: true,
+        };
+    }
+    if (classifierSpec.startsWith("llm:")) {
+        const model = classifierSpec.slice("llm:".length).trim();
+        if (!model) {
+            throw new Error("classifier spec 'llm:' requires a model name");
+        }
+        return {
+            classifier: new LLMClassifier({ model, labels }),
+            isMockClassifier: false,
+        };
+    }
+    if (classifierSpec.startsWith("huggingface:")) {
+        const modelName = classifierSpec.slice("huggingface:".length).trim();
+        if (!modelName) {
+            throw new Error("classifier spec 'huggingface:' requires a model name");
+        }
+        return {
+            classifier: new HuggingFaceClassifier({ modelName }),
+            isMockClassifier: false,
+        };
+    }
+    throw new Error("Unsupported classifier spec. Use: function, llm:<model>, huggingface:<model>");
+}
+function usageText() {
+    return [
+        "Usage: llm-jury <command> [options]",
+        "",
+        "Commands:",
+        "  classify   Classify JSONL inputs and write verdicts JSONL",
+        "  calibrate  Calibrate threshold from labeled JSONL",
+        "",
+        "Common options:",
+        "  --classifier function|llm:<model>|huggingface:<model>",
+        "  --personas content_moderation|legal_compliance|medical_triage|financial_compliance",
+        "  --judge llm|majority|weighted|bayesian",
+        "  --labels safe,unsafe",
+        "  --debate-mode independent|sequential|deliberation|adversarial",
+        "",
+        "Examples:",
+        "  llm-jury classify --input input.jsonl --output verdicts.jsonl --classifier function --judge majority",
+        "  llm-jury calibrate --input calibration.jsonl --classifier function --judge majority",
+    ].join("\n");
+}
+export async function main(argv = process.argv.slice(2)) {
+    if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(`${usageText()}\n`);
+        return 0;
+    }
+    if (argv.includes("--version") || argv.includes("-v")) {
+        process.stdout.write("0.1.0\n");
+        return 0;
+    }
+    const command = argv[0];
+    const classifierSpec = parseArg(argv, "--classifier") ?? "function";
+    const personasKey = parseArg(argv, "--personas") ?? "content_moderation";
+    const judgeKey = parseArg(argv, "--judge") ?? "llm";
+    const judgeModel = parseArg(argv, "--judge-model") ?? "gpt-5-mini";
+    const personaModel = parseArg(argv, "--persona-model") ?? "gpt-5-mini";
+    const rawLabels = parseArg(argv, "--labels");
+    const labels = parseLabels(rawLabels, ["safe", "unsafe"]);
+    const debateConfig = buildDebateConfig(argv);
+    const debateConcurrency = Number(parseArg(argv, "--debate-concurrency") ?? "5");
+    const maxDebateCostRaw = parseArg(argv, "--max-debate-cost");
+    const maxDebateCostUsd = maxDebateCostRaw == null ? undefined : Number(maxDebateCostRaw);
+    if (command === "classify") {
+        const input = parseArg(argv, "--input");
+        const output = parseArg(argv, "--output");
+        const thresholdValue = parseArg(argv, "--threshold");
+        const concurrency = Number(parseArg(argv, "--concurrency") ?? "10");
+        if (!input || !output) {
+            throw new Error("--input and --output are required");
+        }
+        const threshold = thresholdValue ? Number(thresholdValue) : 0.7;
+        const rows = readJsonl(input);
+        const texts = rows.map((row, idx) => String(row.text ?? `row-${idx}`));
+        const { classifier, isMockClassifier } = buildClassifier(classifierSpec, labels, rows);
+        const jury = new Jury({
+            classifier,
+            personas: applyPersonaModel(selectPersonas(personasKey), personaModel),
+            confidenceThreshold: threshold,
+            judge: selectJudge(judgeKey, judgeModel),
+            debateConfig,
+            debateConcurrency,
+            maxDebateCostUsd,
+        });
+        const verdicts = await jury.classifyBatch(texts, isMockClassifier ? 1 : concurrency);
+        writeJsonl(output, verdicts.map((verdict) => toSnakeCaseObject(verdict)));
+        return 0;
+    }
+    if (command === "calibrate") {
+        const input = parseArg(argv, "--input");
+        const errorCost = Number(parseArg(argv, "--error-cost") ?? "10");
+        const escalationCost = Number(parseArg(argv, "--escalation-cost") ?? "0.05");
+        const initialThreshold = Number(parseArg(argv, "--initial-threshold") ?? "0.7");
+        if (!input) {
+            throw new Error("--input is required");
+        }
+        const rows = readJsonl(input);
+        if (rows.length === 0) {
+            throw new Error("input jsonl is empty");
+        }
+        const missingLabels = rows.filter((row) => row.label == null).length;
+        if (missingLabels > 0) {
+            throw new Error(`Calibration input requires a ground-truth 'label' field on every row. Missing labels in ${missingLabels} row(s).`);
+        }
+        const texts = rows.map((row, idx) => String(row.text ?? `row-${idx}`));
+        const expectedLabels = rows.map((row) => String(row.label));
+        const inferenceLabels = resolveCalibrationLabels(rawLabels, expectedLabels);
+        const { classifier } = buildClassifier(classifierSpec, inferenceLabels, rows);
+        const jury = new Jury({
+            classifier,
+            personas: applyPersonaModel(selectPersonas(personasKey), personaModel),
+            confidenceThreshold: initialThreshold,
+            judge: selectJudge(judgeKey, judgeModel),
+            debateConfig,
+            debateConcurrency,
+            maxDebateCostUsd,
+        });
+        const calibrator = new ThresholdCalibrator(jury);
+        const bestThreshold = await calibrator.calibrate({
+            texts,
+            labels: expectedLabels,
+            errorCost,
+            escalationCost,
+        });
+        const report = calibrator.calibrationReport();
+        report.bestThreshold = bestThreshold;
+        process.stdout.write(`${JSON.stringify(toSnakeCaseObject(report))}\n`);
+        return 0;
+    }
+    throw new Error("Supported commands: classify, calibrate");
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().then((code) => {
+        process.exitCode = code;
+    }, (err) => {
+        console.error(err);
+        process.exitCode = 1;
+    });
+}

package/dist/debate/engine.d.ts

@@ -0,0 +1,48 @@
+import type { ClassificationResult } from "../classifiers/base.ts";
+import type { LLMClient } from "../llm/client.ts";
+import type { Persona, PersonaResponse } from "../personas/base.ts";
+export declare const DebateMode: {
+    readonly INDEPENDENT: "independent";
+    readonly SEQUENTIAL: "sequential";
+    readonly DELIBERATION: "deliberation";
+    readonly ADVERSARIAL: "adversarial";
+};
+export type DebateMode = (typeof DebateMode)[keyof typeof DebateMode];
+export type DebateTranscript = {
+    inputText: string;
+    primaryResult: ClassificationResult;
+    rounds: PersonaResponse[][];
+    summary?: string;
+    durationMs: number;
+    totalTokens: number;
+    totalCostUsd: number | null;
+};
+export declare class DebateConfig {
+    mode: DebateMode;
+    maxRounds: number;
+    includePrimaryResult: boolean;
+    includeConfidence: boolean;
+    constructor(options?: Partial<DebateConfig>);
+}
+export declare class DebateEngine {
+    private personas;
+    private config;
+    private llmClient;
+    private concurrency;
+    constructor(personas: Persona[], config?: DebateConfig, llmClient?: LLMClient, concurrency?: number);
+    static jsonResponseBlock(): string;
+    debate(text: string, primaryResult: ClassificationResult, labels: string[], maxCostUsd?: number | null): Promise<DebateTranscript>;
+    runRound(text: string, primaryResult: ClassificationResult, labels: string[], priorRounds: PersonaResponse[][]): Promise<PersonaResponse[]>;
+    runDeliberationRound(text: string, primaryResult: ClassificationResult, labels: string[], priorRounds: PersonaResponse[][]): Promise<PersonaResponse[]>;
+    queryPersona(persona: Persona, text: string, primaryResult: ClassificationResult, labels: string[], priorRounds: PersonaResponse[][]): Promise<PersonaResponse>;
+    queryPersonaDeliberation(persona: Persona, text: string, primaryResult: ClassificationResult, labels: string[], priorRounds: PersonaResponse[][]): Promise<PersonaResponse>;
+    buildPersonaPrompt(persona: Persona, text: string, primary: ClassificationResult, labels: string[], priorRounds: PersonaResponse[][]): string;
+    buildDeliberationPrompt(persona: Persona, text: string, primary: ClassificationResult, labels: string[], priorRounds: PersonaResponse[][]): string;
+    summarise(text: string, labels: string[], rounds: PersonaResponse[][]): Promise<{
+        summary: string;
+        tokens: number;
+        cost: number;
+    }>;
+    parsePersonaResponse(raw: string, personaName: string): PersonaResponse;
+    consensusReached(roundResponses: PersonaResponse[]): boolean;
+}

package/dist/debate/engine.js

@@ -0,0 +1,309 @@
+import { LiteLLMClient } from "../llm/client.js";
+import { stripMarkdown } from "../utils.js";
+const SUMMARISATION_PROMPT = "You are a neutral summarisation agent. You have observed a structured debate " +
+    "among domain experts about classifying a piece of text.\n\n" +
+    "Produce a concise synthesis that covers:\n" +
+    "1. The main arguments from each side\n" +
+    "2. Points of consensus among the experts\n" +
+    "3. Unresolved disagreements\n\n" +
+    "Be factual and impartial. Do not add your own classification.";
+const DELIBERATION_INSTRUCTIONS = "You have seen the initial assessments from all experts on this input. " +
+    "You MUST:\n" +
+    "(i) Engage with at least one other expert's reasoning — agree or disagree " +
+    "with supporting rationale.\n" +
+    "(ii) Revise your own classification if you find their counter-arguments compelling.\n" +
+    "(iii) Re-evaluate the input through the interpretive lens of at least one other expert's " +
+    "perspective, considering both intent and impact.\n\n" +
+    "Then provide your revised assessment.";
+export const DebateMode = {
+    INDEPENDENT: "independent",
+    SEQUENTIAL: "sequential",
+    DELIBERATION: "deliberation",
+    ADVERSARIAL: "adversarial",
+};
+export class DebateConfig {
+    mode;
+    maxRounds;
+    includePrimaryResult;
+    includeConfidence;
+    constructor(options = {}) {
+        this.mode = options.mode ?? DebateMode.DELIBERATION;
+        this.maxRounds = options.maxRounds ?? 2;
+        this.includePrimaryResult = options.includePrimaryResult ?? true;
+        this.includeConfidence = options.includeConfidence ?? true;
+    }
+}
+export class DebateEngine {
+    personas;
+    config;
+    llmClient;
+    concurrency;
+    constructor(personas, config = new DebateConfig(), llmClient = new LiteLLMClient(), concurrency = 5) {
+        this.personas = personas;
+        this.config = config;
+        this.llmClient = llmClient;
+        this.concurrency = Math.max(1, concurrency);
+    }
+    static jsonResponseBlock() {
+        return ("\n## Your Assessment\n\n" +
+            "Provide your classification. Respond ONLY with valid JSON:\n" +
+            "```json\n" +
+            "{\n" +
+            '  "label": "<your classification>",\n' +
+            '  "confidence": <0.0-1.0>,\n' +
+            '  "reasoning": "<your full reasoning>",\n' +
+            '  "key_factors": ["<factor 1>", "<factor 2>"],\n' +
+            '  "dissent_notes": "<optional rebuttal against opposing side>"\n' +
+            "}\n" +
+            "```");
+    }
+    async debate(text, primaryResult, labels, maxCostUsd = null) {
+        const start = Date.now();
+        const rounds = [];
+        let totalTokens = 0;
+        let totalCostUsd = 0;
+        if (this.personas.length === 0) {
+            return {
+                inputText: text,
+                primaryResult,
+                rounds: [],
+                durationMs: Date.now() - start,
+                totalTokens: 0,
+                totalCostUsd: 0,
+            };
+        }
+        if (this.config.mode === DebateMode.INDEPENDENT || this.config.mode === DebateMode.ADVERSARIAL) {
+            const responses = await this.runRound(text, primaryResult, labels, []);
+            rounds.push(responses);
+            responses.forEach((response) => {
+                totalTokens += Number(response.tokensUsed ?? 0);
+                totalCostUsd += Number(response.costUsd ?? 0);
+            });
+        }
+        else if (this.config.mode === DebateMode.SEQUENTIAL) {
+            const responses = [];
+            for (const persona of this.personas) {
+                const response = await this.queryPersona(persona, text, primaryResult, labels, responses.length > 0 ? [responses] : []);
+                responses.push(response);
+                totalTokens += Number(response.tokensUsed ?? 0);
+                totalCostUsd += Number(response.costUsd ?? 0);
+                if (maxCostUsd != null && totalCostUsd > maxCostUsd) {
+                    break;
+                }
+            }
+            rounds.push(responses);
+        }
+        else if (this.config.mode === DebateMode.DELIBERATION) {
+            const firstRound = await this.runRound(text, primaryResult, labels, []);
+            rounds.push(firstRound);
+            firstRound.forEach((response) => {
+                totalTokens += Number(response.tokensUsed ?? 0);
+                totalCostUsd += Number(response.costUsd ?? 0);
+            });
+            if (maxCostUsd != null && totalCostUsd > maxCostUsd) {
+                return {
+                    inputText: text,
+                    primaryResult,
+                    rounds,
+                    durationMs: Date.now() - start,
+                    totalTokens,
+                    totalCostUsd,
+                };
+            }
+            for (let i = 1; i < Math.max(1, this.config.maxRounds); i += 1) {
+                const current = await this.runDeliberationRound(text, primaryResult, labels, rounds);
+                rounds.push(current);
+                current.forEach((response) => {
+                    totalTokens += Number(response.tokensUsed ?? 0);
+                    totalCostUsd += Number(response.costUsd ?? 0);
+                });
+                if (maxCostUsd != null && totalCostUsd > maxCostUsd) {
+                    break;
+                }
+                if (this.consensusReached(current)) {
+                    break;
+                }
+            }
+            let summary;
+            if (maxCostUsd == null || totalCostUsd <= maxCostUsd) {
+                const summaryResult = await this.summarise(text, labels, rounds);
+                totalTokens += summaryResult.tokens;
+                totalCostUsd += summaryResult.cost;
+                summary = summaryResult.summary;
+            }
+            return {
+                inputText: text,
+                primaryResult,
+                rounds,
+                summary,
+                durationMs: Date.now() - start,
+                totalTokens,
+                totalCostUsd,
+            };
+        }
+        return {
+            inputText: text,
+            primaryResult,
+            rounds,
+            durationMs: Date.now() - start,
+            totalTokens,
+            totalCostUsd,
+        };
+    }
+    async runRound(text, primaryResult, labels, priorRounds) {
+        const out = [];
+        for (let i = 0; i < this.personas.length; i += this.concurrency) {
+            const batch = this.personas.slice(i, i + this.concurrency);
+            const responses = await Promise.all(batch.map((persona) => this.queryPersona(persona, text, primaryResult, labels, priorRounds)));
+            out.push(...responses);
+        }
+        return out;
+    }
+    async runDeliberationRound(text, primaryResult, labels, priorRounds) {
+        const out = [];
+        for (let i = 0; i < this.personas.length; i += this.concurrency) {
+            const batch = this.personas.slice(i, i + this.concurrency);
+            const responses = await Promise.all(batch.map((persona) => this.queryPersonaDeliberation(persona, text, primaryResult, labels, priorRounds)));
+            out.push(...responses);
+        }
+        return out;
+    }
+    async queryPersona(persona, text, primaryResult, labels, priorRounds) {
+        const prompt = this.buildPersonaPrompt(persona, text, primaryResult, labels, priorRounds);
+        const payload = await this.llmClient.complete(persona.model, persona.systemPrompt, prompt, persona.temperature);
+        const parsed = this.parsePersonaResponse(payload.content, persona.name);
+        parsed.rawResponse = payload.content;
+        parsed.tokensUsed = Number(payload.tokens ?? 0);
+        parsed.costUsd = Number(payload.costUsd ?? 0);
+        return parsed;
+    }
+    async queryPersonaDeliberation(persona, text, primaryResult, labels, priorRounds) {
+        const prompt = this.buildDeliberationPrompt(persona, text, primaryResult, labels, priorRounds);
+        const payload = await this.llmClient.complete(persona.model, persona.systemPrompt, prompt, persona.temperature);
+        const parsed = this.parsePersonaResponse(payload.content, persona.name);
+        parsed.rawResponse = payload.content;
+        parsed.tokensUsed = Number(payload.tokens ?? 0);
+        parsed.costUsd = Number(payload.costUsd ?? 0);
+        return parsed;
+    }
+    buildPersonaPrompt(persona, text, primary, labels, priorRounds) {
+        const parts = [];
+        parts.push(`## Persona\n\n${persona.name}: ${persona.role}\n`);
+        parts.push(`## Input to Classify\n\n${text}\n`);
+        parts.push(`## Available Labels\n\n${labels.join(", ")}\n`);
+        if (this.config.mode === DebateMode.ADVERSARIAL) {
+            const personaIndex = this.personas.indexOf(persona);
+            const stance = personaIndex % 2 === 0 ? "Prosecution" : "Defense";
+            parts.push("## Adversarial Role\n\n" +
+                `You are assigned the **${stance}** side. Argue this stance rigorously while staying truthful to the evidence.\n`);
+        }
+        if (this.config.includePrimaryResult) {
+            const confidence = this.config.includeConfidence ? ` (confidence: ${primary.confidence.toFixed(2)})` : "";
+            parts.push("## Primary Classifier Result\n\n" +
+                `Label: ${primary.label}${confidence}\n` +
+                "Note: This was flagged as low-confidence and escalated to you.\n");
+        }
+        if (priorRounds.length > 0) {
+            parts.push("## Previous Assessments\n");
+            priorRounds.forEach((roundResponses, idx) => {
+                parts.push(`\n### Round ${idx + 1}\n`);
+                for (const response of roundResponses) {
+                    parts.push(`**${response.personaName}**: ${response.label} (confidence: ${response.confidence.toFixed(2)})\n` +
+                        `Reasoning: ${response.reasoning}\n`);
+                }
+            });
+        }
+        parts.push(DebateEngine.jsonResponseBlock());
+        return parts.join("\n");
+    }
+    buildDeliberationPrompt(persona, text, primary, labels, priorRounds) {
+        const parts = [];
+        parts.push(`## Persona\n\n${persona.name}: ${persona.role}\n`);
+        parts.push(`## Input to Classify\n\n${text}\n`);
+        parts.push(`## Available Labels\n\n${labels.join(", ")}\n`);
+        if (this.config.includePrimaryResult) {
+            const confidence = this.config.includeConfidence ? ` (confidence: ${primary.confidence.toFixed(2)})` : "";
+            parts.push("## Primary Classifier Result\n\n" +
+                `Label: ${primary.label}${confidence}\n` +
+                "Note: This was flagged as low-confidence and escalated to you.\n");
+        }
+        if (priorRounds.length > 0) {
+            priorRounds.forEach((roundResponses, idx) => {
+                if (idx === 0) {
+                    parts.push("## Initial Expert Opinions\n");
+                }
+                else {
+                    parts.push(`## Revised Opinions (Round ${idx + 1})\n`);
+                }
+                for (const response of roundResponses) {
+                    parts.push(`**${response.personaName}**: ${response.label} (confidence: ${response.confidence.toFixed(2)})\n` +
+                        `Reasoning: ${response.reasoning}\n`);
+                }
+            });
+        }
+        parts.push(`\n## Deliberation Instructions\n\n${DELIBERATION_INSTRUCTIONS}\n`);
+        parts.push(DebateEngine.jsonResponseBlock());
+        return parts.join("\n");
+    }
+    async summarise(text, labels, rounds) {
+        const parts = [];
+        parts.push(`## Input\n\n${text}\n`);
+        parts.push(`## Available Labels\n\n${labels.join(", ")}\n`);
+        parts.push("## Expert Debate\n");
+        rounds.forEach((roundResponses, idx) => {
+            if (idx === 0) {
+                parts.push("\n### Initial Expert Opinions\n");
+            }
+            else {
+                parts.push(`\n### Revised Opinions (Round ${idx + 1})\n`);
+            }
+            for (const response of roundResponses) {
+                parts.push(`**${response.personaName}**: ${response.label} (confidence: ${response.confidence.toFixed(2)})\n` +
+                    `Reasoning: ${response.reasoning}\n`);
+            }
+        });
+        const model = this.personas[0]?.model ?? "gpt-5-mini";
+        const payload = await this.llmClient.complete(model, SUMMARISATION_PROMPT, parts.join("\n"), 0);
+        return {
+            summary: payload.content,
+            tokens: Number(payload.tokens ?? 0),
+            cost: Number(payload.costUsd ?? 0),
+        };
+    }
+    parsePersonaResponse(raw, personaName) {
+        let parsed;
+        try {
+            const candidate = JSON.parse(stripMarkdown(raw));
+            if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+                throw new Error("Persona response must be a JSON object.");
+            }
+            parsed = candidate;
+        }
+        catch {
+            return {
+                personaName,
+                label: "unknown",
+                confidence: 0,
+                reasoning: `Failed to parse persona response: ${raw.slice(0, 200)}`,
+                keyFactors: [],
+            };
+        }
+        return {
+            personaName,
+            label: String(parsed.label ?? "unknown"),
+            confidence: Number(parsed.confidence ?? 0),
+            reasoning: String(parsed.reasoning ?? ""),
+            keyFactors: Array.isArray(parsed.key_factors) ? parsed.key_factors.map(String) : [],
+            dissentNotes: parsed.dissent_notes,
+            tokensUsed: 0,
+            costUsd: 0,
+        };
+    }
+    consensusReached(roundResponses) {
+        if (roundResponses.length === 0) {
+            return false;
+        }
+        const labels = new Set(roundResponses.map((r) => r.label));
+        return labels.size === 1;
+    }
+}

package/dist/debate/index.d.ts

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

package/dist/debate/index.js

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