dsh-model-jury 0.1.0

package/lib/council-service.d.ts

@@ -0,0 +1,33 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Config } from './config.js';
+import { type CouncilRunResult } from './protocol/state-machine.js';
+import type { CouncilStyle } from './protocol/prompts.js';
+import type { CouncilSeatId, SeatHealth } from './seats/types.js';
+/** Persisted successful Council run returned to the command adapter. */
+export interface StoredCouncilRun {
+    readonly result: CouncilRunResult;
+    readonly report: string;
+    readonly runId: string;
+    readonly directory: string;
+}
+/** Complete doctor result for all configured seats. */
+export interface CouncilDoctorResult {
+    readonly ready: boolean;
+    readonly seats: Readonly<Record<CouncilSeatId, SeatHealth>>;
+    readonly codexReadOnlyEnforcement: 'prompt-only';
+}
+/** Orchestrates seats, deterministic protocol, persistence, doctor, and reporting. */
+export declare class CouncilService {
+    private readonly ctx;
+    private readonly config;
+    private readonly seats;
+    constructor(ctx: Context, config: Config);
+    /** Run real minimal provider probes concurrently. */
+    doctor(parent: Agent, signal: AbortSignal): Promise<CouncilDoctorResult>;
+    /** Execute and persist one complete Council run. */
+    run(question: string, style: CouncilStyle, parent: Agent, signal: AbortSignal): Promise<StoredCouncilRun>;
+}
+/** Render doctor status without ever printing credential values. */
+export declare function renderDoctor(result: CouncilDoctorResult): string;
+//# sourceMappingURL=council-service.d.ts.map

package/lib/council-service.js

@@ -0,0 +1,86 @@
+import { RunStore } from './persistence/run-store.js';
+import { renderReport } from './protocol/report.js';
+import { CouncilStateMachine } from './protocol/state-machine.js';
+import { CodexSeat } from './seats/codex-seat.js';
+import { LlmSeat } from './seats/llm-seat.js';
+import { SEAT_NAMES } from './seats/types.js';
+import { UnavailableSeat } from './seats/unavailable-seat.js';
+function publicConfig(config) {
+    return {
+        storageDir: config.storageDir,
+        maxQuestionChars: config.maxQuestionChars,
+        maxFieldChars: config.maxFieldChars,
+        codex: config.codex,
+        glm: config.glm,
+        deepseek: config.deepseek,
+    };
+}
+/** Orchestrates seats, deterministic protocol, persistence, doctor, and reporting. */
+export class CouncilService {
+    ctx;
+    config;
+    seats;
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.seats = [
+            new CodexSeat(ctx, config.codex),
+            config.glm.model === null
+                ? new UnavailableSeat('glm', config.glm.provider, 'GLM model is not configured in Council settings')
+                : new LlmSeat('glm', ctx, config.glm),
+            config.deepseek.model === null
+                ? new UnavailableSeat('deepseek', config.deepseek.provider, 'DeepSeek model is not configured in Council settings')
+                : new LlmSeat('deepseek', ctx, config.deepseek),
+        ];
+    }
+    /** Run real minimal provider probes concurrently. */
+    async doctor(parent, signal) {
+        const entries = await Promise.all(this.seats.map(async (seat) => [seat.id, await seat.healthCheck(parent, signal)]));
+        const seats = Object.fromEntries(entries);
+        return {
+            ready: Object.values(seats).every(health => health.ok),
+            seats,
+            codexReadOnlyEnforcement: 'prompt-only',
+        };
+    }
+    /** Execute and persist one complete Council run. */
+    async run(question, style, parent, signal) {
+        const normalized = question.trim();
+        if (normalized.length === 0)
+            throw new Error('Council question must not be empty');
+        if (normalized.length > this.config.maxQuestionChars) {
+            throw new Error(`Council question exceeds ${this.config.maxQuestionChars} characters`);
+        }
+        const workspace = parent.session.header.cwd ?? process.cwd();
+        const store = await RunStore.create(workspace, this.config.storageDir, normalized, style, publicConfig(this.config));
+        const observer = {
+            stateChanged: state => store.writeJson('state.json', { state, updatedAt: new Date().toISOString() }),
+            prompt: (round, seat, prompt) => store.writeText(`prompts/${round}/${seat}.txt`, prompt),
+            response: (round, seat, response) => store.writeJson(`${round}/${seat}.json`, response),
+            failure: (failure, metadata) => store.writeJson(`${failure.round}/${failure.seat}.json`, { success: false, failure, ...metadata === undefined ? {} : { metadata } }),
+            redistribution: metadata => store.writeJson('redistribution.json', metadata),
+        };
+        const machine = new CouncilStateMachine(this.seats, this.config.maxFieldChars, observer);
+        const result = await machine.run(normalized, style, parent, signal);
+        const report = renderReport(result, store.id);
+        const calls = [...result.round1.values(), ...result.round2.values(), ...result.round3.values()]
+            .map(response => response.metadata);
+        await Promise.all([
+            store.writeJson('verdict.json', result.verdict),
+            store.writeJson('calls.json', calls),
+            store.writeText('report.md', report),
+        ]);
+        return { result, report, runId: store.id, directory: store.directory };
+    }
+}
+/** Render doctor status without ever printing credential values. */
+export function renderDoctor(result) {
+    const lines = ['Model Jury Providers', ''];
+    for (const seat of ['gpt', 'glm', 'deepseek']) {
+        const health = result.seats[seat];
+        lines.push(`${seat === 'gpt' ? 'GPT / Codex' : SEAT_NAMES[seat]}:`, health.ok ? 'PASS' : 'FAIL', `Provider: ${health.provider}`, `Model: ${health.model ?? 'not configured'}`, ...(seat === 'gpt' && health.ok ? ['Authentication: native Codex / ChatGPT subscription'] : []), `Duration: ${health.durationMs} ms`, `Diagnostic: ${health.detail}`, '');
+    }
+    lines.push('Codex read-only enforcement:', 'LIMITATION — DSH exposes no strict read-only Codex subagent mode; Model Jury uses mutation-prohibiting prompts.', '', `Model Jury: ${result.ready ? 'READY' : 'NOT READY'}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=council-service.js.map

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { Config, type Config as CouncilConfig } from './config.js';
+export declare const name = "dsh-model-jury";
+export declare const inject: string[];
+export { Config };
+export type { CouncilConfig };
+export { CouncilService } from './council-service.js';
+export type { CouncilRunResult } from './protocol/state-machine.js';
+export type { CouncilVerdict } from './protocol/aggregate.js';
+export type { CouncilSeat, CouncilSeatRequest, CouncilSeatResponse } from './seats/types.js';
+/** Mount the Council protocol service and the public Model Jury command. */
+export declare function apply(ctx: Context, config: CouncilConfig): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,12 @@
+import { registerCouncilCommand } from './command.js';
+import { Config } from './config.js';
+import { CouncilService } from './council-service.js';
+export const name = 'dsh-model-jury';
+export const inject = ['commands', 'llm', 'subagents'];
+export { Config };
+export { CouncilService } from './council-service.js';
+/** Mount the Council protocol service and the public Model Jury command. */
+export function apply(ctx, config) {
+    registerCouncilCommand(ctx, new CouncilService(ctx, config));
+}
+//# sourceMappingURL=index.js.map

package/lib/persistence/run-store.d.ts

@@ -0,0 +1,15 @@
+/** Replace credential-shaped fields before any value reaches disk. */
+export declare function redactSecrets(value: unknown): unknown;
+/** Durable owner-only artifact store for one Council run. */
+export declare class RunStore {
+    readonly id: string;
+    readonly directory: string;
+    private constructor();
+    /** Create the run tree and persist safe request/config snapshots. */
+    static create(workspace: string, storageDir: string, question: string, style: string, config: unknown, now?: Date): Promise<RunStore>;
+    /** Atomically persist a redacted JSON artifact beneath this run. */
+    writeJson(relativePath: string, value: unknown): Promise<void>;
+    /** Atomically persist a text artifact beneath this run. */
+    writeText(relativePath: string, text: string): Promise<void>;
+}
+//# sourceMappingURL=run-store.d.ts.map

package/lib/persistence/run-store.js

@@ -0,0 +1,55 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+const SECRET_FIELD = /^(?:api[_-]?key|token|access[_-]?token|refresh[_-]?token|authorization|credentials?|cookie|password|client[_-]?secret|secret)$/iu;
+/** Replace credential-shaped fields before any value reaches disk. */
+export function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        key,
+        SECRET_FIELD.test(key) ? '[REDACTED]' : redactSecrets(entry),
+    ]));
+}
+function runId(now) {
+    const timestamp = now.toISOString().replace(/[-:.]/gu, '').replace('Z', 'Z');
+    return `${timestamp}-${randomUUID().slice(0, 8)}`;
+}
+/** Durable owner-only artifact store for one Council run. */
+export class RunStore {
+    id;
+    directory;
+    constructor(root, id) {
+        this.id = id;
+        this.directory = join(root, 'runs', id);
+    }
+    /** Create the run tree and persist safe request/config snapshots. */
+    static async create(workspace, storageDir, question, style, config, now = new Date()) {
+        const store = new RunStore(resolve(workspace, storageDir), runId(now));
+        await mkdir(store.directory, { recursive: true, mode: 0o700 });
+        await Promise.all([
+            store.writeJson('request.json', { question, style, createdAt: now.toISOString() }),
+            store.writeJson('config.json', config),
+        ]);
+        return store;
+    }
+    /** Atomically persist a redacted JSON artifact beneath this run. */
+    async writeJson(relativePath, value) {
+        const path = join(this.directory, relativePath);
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        await writeFile(temporary, `${JSON.stringify(redactSecrets(value), null, 2)}\n`, { mode: 0o600 });
+        await rename(temporary, path);
+    }
+    /** Atomically persist a text artifact beneath this run. */
+    async writeText(relativePath, text) {
+        const path = join(this.directory, relativePath);
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        await writeFile(temporary, text.endsWith('\n') ? text : `${text}\n`, { mode: 0o600 });
+        await rename(temporary, path);
+    }
+}
+//# sourceMappingURL=run-store.js.map

package/lib/protocol/aggregate.d.ts

@@ -0,0 +1,40 @@
+import type { CouncilSeatId } from '../seats/types.js';
+import type { AnonymizationMap } from './anonymize.js';
+import type { PreferredPosition, Round1Response, Round3Response } from './schemas.js';
+/** One failed provider call retained for the verdict. */
+export interface CouncilFailure {
+    readonly seat: CouncilSeatId;
+    readonly round: 'round1' | 'round2' | 'round3';
+    readonly error: string;
+}
+/** Deterministic aggregate over structured final votes. */
+export interface CouncilVerdict {
+    readonly valid: boolean;
+    readonly result: 'unanimous' | 'majority' | 'split' | 'degraded' | 'failed';
+    readonly voteStatus: 'unanimous' | 'majority' | 'split';
+    readonly quorum: '3/3' | '2/3' | '0-1/3';
+    readonly successfulSeats: readonly CouncilSeatId[];
+    readonly failedSeats: readonly CouncilSeatId[];
+    readonly votes: Readonly<Record<string, number>>;
+    readonly winningChoice: PreferredPosition | null;
+    readonly recommendation: string | null;
+    readonly consensus: readonly string[];
+    readonly majorityView: readonly string[];
+    readonly minorityView: readonly string[];
+    readonly criticalRisks: readonly {
+        seat: CouncilSeatId;
+        category: string;
+        reason: string;
+    }[];
+    readonly criticalReviewRequired: boolean;
+    readonly unresolvedQuestions: readonly string[];
+    readonly evidenceStillNeeded: readonly string[];
+    readonly confidence: Partial<Record<CouncilSeatId, number>>;
+    readonly changedMindCount: number;
+    readonly failures: readonly CouncilFailure[];
+    readonly anonymization: AnonymizationMap;
+    readonly hybridSemanticCaveat: boolean;
+}
+/** Aggregate explicit structured choices without semantic clustering. */
+export declare function aggregateCouncil(finals: ReadonlyMap<CouncilSeatId, Round3Response>, round1: ReadonlyMap<CouncilSeatId, Round1Response>, mapping: AnonymizationMap, failures: readonly CouncilFailure[]): CouncilVerdict;
+//# sourceMappingURL=aggregate.d.ts.map

package/lib/protocol/aggregate.js

@@ -0,0 +1,87 @@
+import { SEAT_NAMES } from '../seats/types.js';
+function unique(values) {
+    return [...new Set(values.map(value => value.trim()).filter(Boolean))];
+}
+function consensusPoints(finals) {
+    const counts = new Map();
+    for (const response of finals.values()) {
+        for (const point of unique(response.agreement_points)) {
+            const key = point.toLocaleLowerCase();
+            const hit = counts.get(key);
+            counts.set(key, { text: hit?.text ?? point, count: (hit?.count ?? 0) + 1 });
+        }
+    }
+    return [...counts.values()].filter(hit => hit.count >= 2).map(hit => hit.text);
+}
+function normalizedRiskCategory(category) {
+    return category.trim().toLocaleLowerCase().replace(/[\s_-]+/gu, ' ');
+}
+/** Aggregate explicit structured choices without semantic clustering. */
+export function aggregateCouncil(finals, round1, mapping, failures) {
+    const successfulSeats = [...finals.keys()];
+    const failedSeats = ['gpt', 'glm', 'deepseek'].filter(seat => !finals.has(seat));
+    const votes = new Map();
+    for (const response of finals.values()) {
+        votes.set(response.preferred_position, (votes.get(response.preferred_position) ?? 0) + 1);
+    }
+    const orderedVotes = [...votes.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+    const top = orderedVotes[0];
+    const successCount = successfulSeats.length;
+    const topCount = top?.[1] ?? 0;
+    const voteStatus = successCount > 0 && topCount === successCount
+        ? 'unanimous'
+        : topCount >= 2
+            ? 'majority'
+            : 'split';
+    const quorum = successCount === 3 ? '3/3' : successCount === 2 ? '2/3' : '0-1/3';
+    const valid = successCount >= 2;
+    const result = !valid ? 'failed' : successCount === 2 ? 'degraded' : voteStatus;
+    const winningChoice = voteStatus === 'split' ? null : top?.[0] ?? null;
+    const winners = winningChoice === null
+        ? []
+        : successfulSeats.filter(seat => finals.get(seat)?.preferred_position === winningChoice);
+    const dissenters = successfulSeats.filter(seat => !winners.includes(seat));
+    const sortedWinners = [...winners].sort((left, right) => ((finals.get(right)?.confidence ?? 0) - (finals.get(left)?.confidence ?? 0)));
+    const recommendation = sortedWinners[0] === undefined
+        ? null
+        : finals.get(sortedWinners[0])?.final_recommendation ?? null;
+    const majorityView = winners.map(seat => `${SEAT_NAMES[seat]}: ${finals.get(seat)?.final_recommendation ?? ''}`);
+    const minorityView = dissenters.map(seat => `${SEAT_NAMES[seat]}: ${finals.get(seat)?.final_recommendation ?? ''}`);
+    const criticalRisks = successfulSeats.flatMap((seat) => {
+        const risk = finals.get(seat)?.critical_risk;
+        return risk?.active && risk.category !== null && risk.reason !== null
+            ? [{ seat, category: risk.category, reason: risk.reason }]
+            : [];
+    });
+    const riskCounts = new Map();
+    for (const risk of criticalRisks) {
+        const key = normalizedRiskCategory(risk.category);
+        riskCounts.set(key, (riskCounts.get(key) ?? 0) + 1);
+    }
+    const criticalReviewRequired = [...riskCounts.values()].some(count => count >= 2);
+    const confidence = Object.fromEntries(successfulSeats.map(seat => [seat, finals.get(seat)?.confidence ?? 0]));
+    return {
+        valid,
+        result,
+        voteStatus,
+        quorum,
+        successfulSeats,
+        failedSeats,
+        votes: Object.fromEntries(orderedVotes),
+        winningChoice,
+        recommendation,
+        consensus: consensusPoints(finals),
+        majorityView,
+        minorityView,
+        criticalRisks,
+        criticalReviewRequired,
+        unresolvedQuestions: unique([...finals.values()].flatMap(response => response.disagreement_points)),
+        evidenceStillNeeded: unique([...round1.values()].flatMap(response => response.evidence_needed)),
+        confidence,
+        changedMindCount: [...finals.values()].filter(response => response.changed_mind).length,
+        failures,
+        anonymization: mapping,
+        hybridSemanticCaveat: winningChoice === 'hybrid' && topCount >= 2,
+    };
+}
+//# sourceMappingURL=aggregate.js.map

package/lib/protocol/anonymize.d.ts

@@ -0,0 +1,20 @@
+import type { CouncilSeatId } from '../seats/types.js';
+/** Anonymous position labels used in review and votes. */
+export type PositionLabel = 'P1' | 'P2' | 'P3';
+/** Per-run private seat-to-position assignment. */
+export type AnonymizationMap = Readonly<Record<CouncilSeatId, PositionLabel>>;
+/** Randomize a complete three-seat mapping with an injectable test source. */
+export declare function createAnonymizationMap(randomIndex?: (upperExclusive: number) => number): AnonymizationMap;
+/** Metadata describing bounded or identity-scrubbed redistribution fields. */
+export interface RedistributionMetadata {
+    readonly truncations: readonly string[];
+    readonly identityRedactions: readonly string[];
+}
+/** Sanitized packet material plus explicit transformation metadata. */
+export interface SanitizedPacket<T> {
+    readonly value: T;
+    readonly metadata: RedistributionMetadata;
+}
+/** Bound strings and remove provider/model names before cross-seat redistribution. */
+export declare function sanitizeForRedistribution<T>(input: T, maxFieldChars: number, identities: readonly string[]): SanitizedPacket<T>;
+//# sourceMappingURL=anonymize.d.ts.map

package/lib/protocol/anonymize.js

@@ -0,0 +1,60 @@
+import { randomInt } from 'node:crypto';
+/** Randomize a complete three-seat mapping with an injectable test source. */
+export function createAnonymizationMap(randomIndex = randomInt) {
+    const labels = ['P1', 'P2', 'P3'];
+    for (let index = labels.length - 1; index > 0; index -= 1) {
+        const swap = randomIndex(index + 1);
+        const current = labels[index];
+        const selected = labels[swap];
+        if (current === undefined || selected === undefined)
+            throw new Error('invalid anonymization random index');
+        labels[index] = selected;
+        labels[swap] = current;
+    }
+    const [gpt, glm, deepseek] = labels;
+    if (gpt === undefined || glm === undefined || deepseek === undefined)
+        throw new Error('incomplete anonymization mapping');
+    return Object.freeze({ gpt, glm, deepseek });
+}
+function identityPattern(identities) {
+    const escaped = identities
+        .map(identity => identity.trim())
+        .filter(identity => identity.length >= 3)
+        .sort((left, right) => right.length - left.length)
+        .map(identity => identity.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&'));
+    return escaped.length === 0 ? undefined : new RegExp(`\\b(?:${escaped.join('|')})\\b`, 'giu');
+}
+/** Bound strings and remove provider/model names before cross-seat redistribution. */
+export function sanitizeForRedistribution(input, maxFieldChars, identities) {
+    const truncations = [];
+    const identityRedactions = [];
+    const pattern = identityPattern(identities);
+    const visit = (value, path) => {
+        if (typeof value === 'string') {
+            const scrubbed = pattern === undefined
+                ? value
+                : value.replace(pattern, () => {
+                    identityRedactions.push(path);
+                    return '[participant identity removed]';
+                });
+            if (scrubbed.length <= maxFieldChars)
+                return scrubbed;
+            truncations.push(path);
+            return `${scrubbed.slice(0, maxFieldChars)}… [truncated by Council]`;
+        }
+        if (Array.isArray(value))
+            return value.map((entry, index) => visit(entry, `${path}[${index}]`));
+        if (typeof value === 'object' && value !== null) {
+            return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, visit(entry, `${path}.${key}`)]));
+        }
+        return value;
+    };
+    return {
+        value: visit(input, '$'),
+        metadata: {
+            truncations: [...new Set(truncations)],
+            identityRedactions: [...new Set(identityRedactions)],
+        },
+    };
+}
+//# sourceMappingURL=anonymize.js.map

package/lib/protocol/prompts.d.ts

@@ -0,0 +1,12 @@
+import type { Round1Response, Round2Response } from './schemas.js';
+/** Supported Council review styles. */
+export type CouncilStyle = 'balanced' | 'adversarial';
+/** Build a blind first-round prompt. */
+export declare function round1Prompt(question: string): string;
+/** Build an anonymous cross-critique prompt. */
+export declare function round2Prompt(question: string, own: Round1Response, positions: Readonly<Record<string, Round1Response>>, style: CouncilStyle): string;
+/** Build the final revision prompt from anonymous prior artifacts. */
+export declare function round3Prompt(question: string, own: Round1Response, positions: Readonly<Record<string, Round1Response>>, critiques: readonly Round2Response[]): string;
+/** Build the only permitted repair request after invalid structured output. */
+export declare function repairPrompt(originalPrompt: string, raw: string, error: string): string;
+//# sourceMappingURL=prompts.d.ts.map

package/lib/protocol/prompts.js

@@ -0,0 +1,102 @@
+const READ_ONLY = [
+    'This is analytical decision support only.',
+    'Do not call tools, edit files, install software, commit, push, deploy, or perform network mutations.',
+    'Do not expose private chain-of-thought. Return concise conclusions and reasons in the requested JSON fields.',
+    'Return JSON only, without Markdown fences or surrounding prose.',
+].join('\n');
+const ROUND1_SHAPE = `{
+  "thesis": "string",
+  "recommendation": "string",
+  "reasoning": ["concise reason"],
+  "assumptions": ["assumption"],
+  "risks": ["risk"],
+  "evidence_needed": ["evidence"],
+  "confidence": 0
+}`;
+const ROUND2_SHAPE = `{
+  "critiques": [{
+    "target": "P1|P2|P3",
+    "strongest_point": "string",
+    "weakest_point": "string",
+    "possible_error": "string",
+    "missing_evidence": "string",
+    "severity": "low|medium|high|critical"
+  }],
+  "preferred_position": "P1|P2|P3|hybrid|undecided",
+  "reason": "string",
+  "confidence": 0
+}`;
+const ROUND3_SHAPE = `{
+  "final_recommendation": "string",
+  "preferred_position": "P1|P2|P3|hybrid|undecided",
+  "changed_mind": true,
+  "change_reason": "string",
+  "agreement_points": ["string"],
+  "disagreement_points": ["string"],
+  "critical_risk": {"active": false, "category": null, "reason": null},
+  "confidence": 0
+}`;
+/** Build a blind first-round prompt. */
+export function round1Prompt(question) {
+    return [
+        READ_ONLY,
+        'Independently analyze the question. You have no access to any other participant response.',
+        'State a concrete recommendation, its assumptions, risks, and evidence gaps.',
+        'Confidence is an integer from 0 through 100.',
+        `Question:\n${question}`,
+        `Required JSON:\n${ROUND1_SHAPE}`,
+    ].join('\n\n');
+}
+function reviewInstructions(style) {
+    const shared = [
+        'Do not seek consensus for its own sake.',
+        'If another position is wrong, say why. If your own position is wrong, acknowledge it.',
+        'Distinguish factual disagreement from preference disagreement.',
+        'Identify missing evidence instead of fabricating certainty.',
+    ];
+    if (style === 'adversarial') {
+        shared.push('Identify the strongest argument against each competing position.', 'Prioritize hidden assumptions, unsupported claims, failure modes, contradictory evidence, and implementation risk.', 'Do not reward agreement. Do not manufacture disagreement where none exists.');
+    }
+    return shared.join('\n');
+}
+/** Build an anonymous cross-critique prompt. */
+export function round2Prompt(question, own, positions, style) {
+    return [
+        READ_ONLY,
+        reviewInstructions(style),
+        'Review the anonymous P1/P2/P3 material. These participant labels are unrelated to any option names in the user question.',
+        'All three labels are included so preferred_position can use one stable per-run label; focus critique on the two positions that differ from your original answer.',
+        'Your original answer is included separately. Do not infer or discuss participant identity.',
+        `Question:\n${question}`,
+        `Your original answer:\n${JSON.stringify(own)}`,
+        `Anonymous positions:\n${JSON.stringify(positions)}`,
+        `Required JSON:\n${ROUND2_SHAPE}`,
+    ].join('\n\n');
+}
+/** Build the final revision prompt from anonymous prior artifacts. */
+export function round3Prompt(question, own, positions, critiques) {
+    return [
+        READ_ONLY,
+        'Update your position only if the evidence or argument justifies it.',
+        'You may retain your position, revise it, merge positions, remain undecided, or explicitly dissent.',
+        'Do not reach consensus merely because other participants agree.',
+        'Set changed_mind accurately and preserve unresolved disagreement.',
+        'All three anonymous labels remain present so preferred_position uses the same stable per-run label.',
+        `Question:\n${question}`,
+        `Your original answer:\n${JSON.stringify(own)}`,
+        `Anonymous positions:\n${JSON.stringify(positions)}`,
+        `Anonymous critiques:\n${JSON.stringify(critiques)}`,
+        `Required JSON:\n${ROUND3_SHAPE}`,
+    ].join('\n\n');
+}
+/** Build the only permitted repair request after invalid structured output. */
+export function repairPrompt(originalPrompt, raw, error) {
+    return [
+        READ_ONLY,
+        'Your previous response failed JSON validation. Repair only its structure and return one valid JSON object.',
+        `Validation error:\n${error}`,
+        `Original task:\n${originalPrompt}`,
+        `Invalid response:\n${raw}`,
+    ].join('\n\n');
+}
+//# sourceMappingURL=prompts.js.map

package/lib/protocol/report.d.ts

@@ -0,0 +1,4 @@
+import type { CouncilRunResult } from './state-machine.js';
+/** Render the complete user-facing Markdown Council report. */
+export declare function renderReport(result: CouncilRunResult, runId: string): string;
+//# sourceMappingURL=report.d.ts.map

package/lib/protocol/report.js

@@ -0,0 +1,101 @@
+import { SEAT_NAMES } from '../seats/types.js';
+function bullets(values, empty = 'None identified.') {
+    return values.length === 0 ? `- ${empty}` : values.map(value => `- ${value}`).join('\n');
+}
+function responseSections(responses) {
+    return ['gpt', 'glm', 'deepseek'].map((seat) => {
+        const response = responses.get(seat);
+        return response === undefined
+            ? `## ${SEAT_NAMES[seat]}\n\nUnavailable or failed in this round.`
+            : `## ${SEAT_NAMES[seat]}\n\n\`\`\`json\n${JSON.stringify(response.value, null, 2)}\n\`\`\``;
+    }).join('\n\n');
+}
+/** Render the complete user-facing Markdown Council report. */
+export function renderReport(result, runId) {
+    const verdict = result.verdict;
+    const resultLabel = verdict.result.toUpperCase();
+    const voteDistribution = Object.entries(verdict.votes).map(([choice, count]) => `${choice}: ${count}`);
+    const confidence = ['gpt', 'glm', 'deepseek'].map(seat => (`${SEAT_NAMES[seat]}: ${verdict.confidence[seat] ?? 'unavailable'}`));
+    const risks = verdict.criticalRisks.map(risk => (`${SEAT_NAMES[risk.seat]} — ${risk.category}: ${risk.reason}`));
+    const mapping = ['gpt', 'glm', 'deepseek'].map(seat => (`| ${SEAT_NAMES[seat]} | ${result.mapping[seat]} |`)).join('\n');
+    const failures = verdict.failures.map(failure => (`${SEAT_NAMES[failure.seat]} ${failure.round}: ${failure.error}`));
+    const recommendation = verdict.recommendation ?? 'No valid Model Jury recommendation was produced.';
+    return `# Model Jury Verdict
+
+## Question
+
+${result.question}
+
+## Result
+
+${resultLabel} — quorum ${verdict.quorum}; vote status ${verdict.voteStatus}.
+
+## Recommendation
+
+${recommendation}
+
+${verdict.hybridSemanticCaveat ? '> Multiple seats selected `hybrid`; their textual hybrids are shown separately and are not assumed to be semantically identical.\n' : ''}${verdict.criticalReviewRequired ? '> **CRITICAL REVIEW REQUIRED:** at least two seats independently flagged a compatible critical-risk category.\n' : ''}
+## Consensus
+
+${bullets(verdict.consensus, 'No exact shared agreement point was stated by at least two seats.')}
+
+## Majority View
+
+${bullets(verdict.majorityView, 'No majority was formed.')}
+
+## Minority / Dissenting View
+
+${bullets(verdict.minorityView, 'No minority view was recorded.')}
+
+## Critical Risks
+
+${bullets(risks, 'No final position activated a critical-risk flag.')}
+
+## Unresolved Questions
+
+${bullets(verdict.unresolvedQuestions)}
+
+## Evidence Still Needed
+
+${bullets(verdict.evidenceStillNeeded)}
+
+## Vote Distribution
+
+${bullets(voteDistribution)}
+
+## Confidence
+
+${confidence.join('\n')}
+
+## Provider Failures
+
+${bullets(failures, 'None.')}
+
+---
+
+# Round 1 — Independent Positions
+
+${responseSections(result.round1)}
+
+# Round 2 — Anonymous Cross-Critique
+
+${responseSections(result.round2)}
+
+# Round 3 — Final Positions
+
+${responseSections(result.round3)}
+
+# Run Metadata
+
+- Run ID: ${runId}
+- Style: ${result.style}
+- Successful final seats: ${verdict.successfulSeats.length}/3
+- Changed-mind count: ${verdict.changedMindCount}
+- Critical review required: ${verdict.criticalReviewRequired ? 'yes' : 'no'}
+
+| Seat | Anonymous position |
+|---|---|
+${mapping}
+`;
+}
+//# sourceMappingURL=report.js.map