@event4u/agent-config 9.1.0 → 9.3.0

package/src/scripts/_lib/adversarial_council_gate.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Adversarial council prove-or-drop gate — coverage (Phase 4).
+ *
+ * Locks the pre-registered dual-threshold semantics: BOTH relative (>=+25%) and
+ * absolute (>=+8pp) residual-recall lift, AND panel FP not worse than baseline
+ * within noise. Guards the base-rate-compression case the council flagged
+ * (high single-judge baseline → relative easy but absolute must still clear).
+ */
+import { describe, expect, it } from 'vitest';
+
+import {
+    ABSOLUTE_LIFT_THRESHOLD_PP,
+    RELATIVE_LIFT_THRESHOLD,
+    evaluateCouncilBench,
+} from './adversarial_council_gate.js';
+
+const CLEAN_FP = { single_judge_fp_rate: 0.05, panel_fp_rate: 0.05, fp_noise_margin: 0.03 };
+
+describe('evaluateCouncilBench', () => {
+    it('exposes the locked thresholds', () => {
+        expect(RELATIVE_LIFT_THRESHOLD).toBe(0.25);
+        expect(ABSOLUTE_LIFT_THRESHOLD_PP).toBe(0.08);
+    });
+
+    it('backs the claim when both recall thresholds and FP pass', () => {
+        const v = evaluateCouncilBench({
+            single_judge_residual_recall: 0.5,
+            panel_residual_recall: 0.65, // +30% relative, +15pp absolute
+            ...CLEAN_FP,
+        });
+        expect(v.relative_pass).toBe(true);
+        expect(v.absolute_pass).toBe(true);
+        expect(v.fp_pass).toBe(true);
+        expect(v.verdict).toBe('backed');
+    });
+
+    it('honest-null when relative passes but absolute fails (base-rate compression)', () => {
+        // baseline 0.90; +0.05 → relative 5.5% (fails) — the high-baseline trap.
+        const v = evaluateCouncilBench({
+            single_judge_residual_recall: 0.9,
+            panel_residual_recall: 0.95,
+            ...CLEAN_FP,
+        });
+        expect(v.verdict).toBe('honest-null');
+        expect(v.reasons.join(' ')).toMatch(/relative lift/);
+    });
+
+    it('honest-null when absolute passes but relative fails', () => {
+        // baseline 0.6; +0.09 absolute (passes) but +15% relative (fails at 25%).
+        const v = evaluateCouncilBench({
+            single_judge_residual_recall: 0.6,
+            panel_residual_recall: 0.69,
+            ...CLEAN_FP,
+        });
+        expect(v.absolute_pass).toBe(true);
+        expect(v.relative_pass).toBe(false);
+        expect(v.verdict).toBe('honest-null');
+    });
+
+    it('honest-null when recall passes but FP regresses beyond noise', () => {
+        const v = evaluateCouncilBench({
+            single_judge_residual_recall: 0.5,
+            panel_residual_recall: 0.7,
+            single_judge_fp_rate: 0.05,
+            panel_fp_rate: 0.12, // +7pp > 3pp noise
+            fp_noise_margin: 0.03,
+        });
+        expect(v.relative_pass).toBe(true);
+        expect(v.absolute_pass).toBe(true);
+        expect(v.fp_pass).toBe(false);
+        expect(v.verdict).toBe('honest-null');
+    });
+
+    it('allows a within-noise FP increase', () => {
+        const v = evaluateCouncilBench({
+            single_judge_residual_recall: 0.5,
+            panel_residual_recall: 0.7,
+            single_judge_fp_rate: 0.05,
+            panel_fp_rate: 0.075, // +2.5pp <= 3pp noise
+            fp_noise_margin: 0.03,
+        });
+        expect(v.fp_pass).toBe(true);
+        expect(v.verdict).toBe('backed');
+    });
+
+    it('handles a zero baseline (infinite relative lift, absolute still gates)', () => {
+        const backed = evaluateCouncilBench({
+            single_judge_residual_recall: 0,
+            panel_residual_recall: 0.2,
+            ...CLEAN_FP,
+        });
+        expect(backed.relative_lift).toBe(Infinity);
+        expect(backed.verdict).toBe('backed'); // +20pp absolute clears
+
+        const nullAbs = evaluateCouncilBench({
+            single_judge_residual_recall: 0,
+            panel_residual_recall: 0.05, // +5pp < 8pp
+            ...CLEAN_FP,
+        });
+        expect(nullAbs.verdict).toBe('honest-null');
+    });
+
+    it('rejects out-of-range inputs', () => {
+        expect(() =>
+            evaluateCouncilBench({
+                single_judge_residual_recall: 1.5,
+                panel_residual_recall: 0.5,
+                ...CLEAN_FP,
+            }),
+        ).toThrow(/\[0,1\]/);
+    });
+});

package/src/scripts/_lib/adversarial_council_gate.ts

@@ -0,0 +1,98 @@
+/**
+ * Adversarial verification council — prove-or-drop gate (Phase 4).
+ *
+ * Pure, deterministic. Encodes the pre-registered `adversarial-council-finding-
+ * coverage` claim (docs/CLAIMS.md, ADR-122) as a machine-checkable verdict on
+ * the two-stage residual-detection benchmark: does a cross-vendor skeptic panel
+ * out-find a single strong judge on the RESIDUAL defect pool (defects that
+ * survived stage 1), at a false-positive rate no worse than baseline on the
+ * controversial-but-correct control?
+ *
+ * Dual threshold, both required, to guard against base-rate compression when the
+ * single-judge residual recall is already high (the council's Round-1 critique):
+ *   (a) relative residual-recall lift >= +25%
+ *   (b) absolute residual-recall lift >= +8 percentage points
+ *   AND panel FP not worse than single-judge FP within the noise margin.
+ *
+ * Thresholds are LOCKED at pre-registration (roadmap Phase 0). This module is the
+ * "countable logic in TS with tests" the anti-lesson mandates — never LLM-computed.
+ *
+ * Design: docs/design/adversarial-council-eval.md
+ */
+
+/** Relative residual-recall lift threshold (fraction). */
+export const RELATIVE_LIFT_THRESHOLD = 0.25;
+/** Absolute residual-recall lift threshold (percentage points, as a fraction). */
+export const ABSOLUTE_LIFT_THRESHOLD_PP = 0.08;
+
+export interface CouncilBenchInputs {
+    /** Single-judge recall on the judge-passed residual pool (0..1). */
+    single_judge_residual_recall: number;
+    /** Panel recall on the same judge-passed residual pool (0..1). */
+    panel_residual_recall: number;
+    /** Single-judge false-positive rate on the controversial-clean control (0..1). */
+    single_judge_fp_rate: number;
+    /** Panel false-positive rate on the same control (0..1). */
+    panel_fp_rate: number;
+    /** Noise margin within which a higher panel FP still counts as "not worse" (0..1). */
+    fp_noise_margin: number;
+}
+
+export type CouncilVerdict = 'backed' | 'honest-null';
+
+export interface CouncilBenchVerdict {
+    relative_lift: number;
+    absolute_lift_pp: number;
+    relative_pass: boolean;
+    absolute_pass: boolean;
+    fp_pass: boolean;
+    verdict: CouncilVerdict;
+    reasons: string[];
+}
+
+function assertUnit(name: string, v: number): void {
+    if (typeof v !== 'number' || Number.isNaN(v) || v < 0 || v > 1) {
+        throw new Error(`${name} must be a number in [0,1], got ${JSON.stringify(v)}`);
+    }
+}
+
+/**
+ * Evaluate the pre-registered dual-threshold gate. Returns `backed` only when
+ * BOTH recall thresholds AND the FP constraint pass; otherwise `honest-null`
+ * (which keeps the surface default-off permanently, like recursive-verification).
+ */
+export function evaluateCouncilBench(inputs: CouncilBenchInputs): CouncilBenchVerdict {
+    assertUnit('single_judge_residual_recall', inputs.single_judge_residual_recall);
+    assertUnit('panel_residual_recall', inputs.panel_residual_recall);
+    assertUnit('single_judge_fp_rate', inputs.single_judge_fp_rate);
+    assertUnit('panel_fp_rate', inputs.panel_fp_rate);
+    assertUnit('fp_noise_margin', inputs.fp_noise_margin);
+
+    const single = inputs.single_judge_residual_recall;
+    const panel = inputs.panel_residual_recall;
+    const absolute_lift_pp = panel - single;
+    // A zero baseline makes the ratio undefined — any positive panel recall is an
+    // infinite relative lift; no lift is zero. This never masks the absolute gate.
+    const relative_lift = single === 0 ? (panel > 0 ? Infinity : 0) : absolute_lift_pp / single;
+
+    const relative_pass = relative_lift >= RELATIVE_LIFT_THRESHOLD;
+    const absolute_pass = absolute_lift_pp >= ABSOLUTE_LIFT_THRESHOLD_PP;
+    const fp_pass = inputs.panel_fp_rate <= inputs.single_judge_fp_rate + inputs.fp_noise_margin;
+
+    const reasons: string[] = [];
+    if (!relative_pass) {
+        reasons.push(`relative lift ${(relative_lift * 100).toFixed(1)}% < ${RELATIVE_LIFT_THRESHOLD * 100}%`);
+    }
+    if (!absolute_pass) {
+        reasons.push(`absolute lift ${(absolute_lift_pp * 100).toFixed(1)}pp < ${ABSOLUTE_LIFT_THRESHOLD_PP * 100}pp`);
+    }
+    if (!fp_pass) {
+        reasons.push(
+            `panel FP ${(inputs.panel_fp_rate * 100).toFixed(1)}% > baseline ${(inputs.single_judge_fp_rate * 100).toFixed(1)}% + noise ${(inputs.fp_noise_margin * 100).toFixed(1)}%`,
+        );
+    }
+
+    const verdict: CouncilVerdict = relative_pass && absolute_pass && fp_pass ? 'backed' : 'honest-null';
+    if (verdict === 'backed') reasons.push('all thresholds met');
+    return { relative_lift, absolute_lift_pp, relative_pass, absolute_pass, fp_pass, verdict, reasons };
+}

package/src/scripts/_lib/adversarial_reconcile.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Adversarial reconciliation core — deterministic coverage (Phase 1).
+ *
+ * Covers: dedup across skeptics, severity aggregation (strict-er wins),
+ * quorum-confidence math, false-positive suppression (demote, never drop),
+ * empty panel, single-finding, unanimous vs split, malformed-input rejection,
+ * and hand-rolled validation of every output against
+ * adversarial-findings.json (no jsonschema runtime dep — mirrors
+ * test_subagent_status_schema.py's approach).
+ */
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+import { describe, expect, it } from 'vitest';
+
+import {
+    type AdversarialFindings,
+    type RawFinding,
+    type SkepticReturn,
+    assertValidRawFinding,
+    findingKey,
+    isSuppressedFalsePositive,
+    reconcileFindings,
+    severityQuorum,
+} from './adversarial_reconcile.js';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SCHEMA_PATH = path.resolve(
+    HERE,
+    '../../skills/subagent-orchestration/schemas/adversarial-findings.json',
+);
+
+const SEVERITIES = new Set(['critical', 'high', 'medium', 'low']);
+const CONFIDENCES = new Set(['high', 'medium', 'low']);
+
+/** Minimal hand-rolled validator matching the schema's required keys + enums. */
+function validateEnvelope(env: AdversarialFindings): void {
+    expect(env).toHaveProperty('panel');
+    expect(env.panel.models.length).toBeGreaterThanOrEqual(1);
+    expect(env.panel.skeptic_count).toBe(env.panel.models.length);
+    for (const bucket of [env.findings, env.false_positives_suppressed]) {
+        for (const f of bucket) {
+            for (const val of [f.id, f.severity, f.category, f.location, f.description, f.confidence]) {
+                expect(typeof val).toBe('string');
+                expect(val.length).toBeGreaterThan(0);
+            }
+            expect(SEVERITIES.has(f.severity)).toBe(true);
+            expect(CONFIDENCES.has(f.confidence)).toBe(true);
+            expect(Array.isArray(f.raised_by)).toBe(true);
+            expect(f.raised_by.length).toBeGreaterThanOrEqual(1);
+            expect(Array.isArray(f.refuted_by)).toBe(true);
+        }
+    }
+}
+
+function raw(over: Partial<RawFinding> = {}): RawFinding {
+    return {
+        severity: 'high',
+        category: 'correctness',
+        location: 'src/a.ts:42',
+        description: 'off-by-one in loop bound',
+        ...over,
+    };
+}
+
+describe('adversarial-findings.json schema', () => {
+    it('parses and declares the finding contract', () => {
+        const schema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf8'));
+        expect(schema.required).toEqual(['panel', 'findings', 'false_positives_suppressed']);
+        expect(schema.additionalProperties).toBe(false);
+        expect(schema.definitions.finding.required).toContain('raised_by');
+        expect(schema.definitions.finding.required).toContain('confidence');
+        expect(schema.definitions.finding.properties.severity.enum).toEqual([
+            'critical',
+            'high',
+            'medium',
+            'low',
+        ]);
+    });
+});
+
+describe('findingKey', () => {
+    it('is location + normalized category', () => {
+        expect(findingKey({ location: 'src/a.ts:42 ', category: 'Security' })).toBe(
+            'src/a.ts:42::security',
+        );
+    });
+});
+
+describe('assertValidRawFinding', () => {
+    it('rejects a bad severity', () => {
+        expect(() => assertValidRawFinding(raw({ severity: 'blocker' as never }))).toThrow(/severity/);
+    });
+    it('rejects an empty location', () => {
+        expect(() => assertValidRawFinding(raw({ location: '  ' }))).toThrow(/location/);
+    });
+    it('accepts a well-formed finding', () => {
+        expect(() => assertValidRawFinding(raw())).not.toThrow();
+    });
+});
+
+describe('severityQuorum', () => {
+    it('high when corroborated by a panel quorum', () => {
+        expect(severityQuorum(2, 0, 2)).toBe('high');
+        expect(severityQuorum(2, 0, 3)).toBe('high');
+    });
+    it('medium when corroborated below quorum', () => {
+        expect(severityQuorum(2, 0, 5)).toBe('medium');
+    });
+    it('medium for a lone raiser on a solo panel', () => {
+        expect(severityQuorum(1, 0, 1)).toBe('medium');
+    });
+    it('low for a single raiser on a multi-skeptic panel', () => {
+        expect(severityQuorum(1, 0, 3)).toBe('low');
+    });
+});
+
+describe('isSuppressedFalsePositive', () => {
+    it('suppresses a lone finding refuted by a strict majority of the rest', () => {
+        expect(isSuppressedFalsePositive(1, 1, 2)).toBe(true); // rest=1, refuted=1 > 0.5
+        expect(isSuppressedFalsePositive(1, 2, 3)).toBe(true); // rest=2, refuted=2 > 1
+    });
+    it('does not suppress when refutation is not a strict majority', () => {
+        expect(isSuppressedFalsePositive(1, 1, 3)).toBe(false); // rest=2, refuted=1 == 1, not > 1
+    });
+    it('never suppresses a corroborated finding', () => {
+        expect(isSuppressedFalsePositive(2, 5, 7)).toBe(false);
+    });
+});
+
+describe('reconcileFindings', () => {
+    it('handles an empty panel', () => {
+        const env = reconcileFindings([]);
+        expect(env.panel).toEqual({ models: [], skeptic_count: 0 });
+        expect(env.findings).toEqual([]);
+        expect(env.false_positives_suppressed).toEqual([]);
+    });
+
+    it('dedups the same defect across skeptics and records both as raisers', () => {
+        const env = reconcileFindings([
+            { model: 'anthropic:x', findings: [raw()] },
+            { model: 'openai:y', findings: [raw({ description: 'the loop reads one past the end of the array' })] },
+        ]);
+        expect(env.findings).toHaveLength(1);
+        expect(env.findings[0]!.raised_by.sort()).toEqual(['anthropic:x', 'openai:y']);
+        expect(env.findings[0]!.confidence).toBe('high'); // 2/2 = quorum
+        // Longest description wins.
+        expect(env.findings[0]!.description).toMatch(/one past the end/);
+        validateEnvelope(env);
+    });
+
+    it('aggregates severity strict-er-wins', () => {
+        const env = reconcileFindings([
+            { model: 'a', findings: [raw({ severity: 'medium' })] },
+            { model: 'b', findings: [raw({ severity: 'critical' })] },
+        ]);
+        expect(env.findings[0]!.severity).toBe('critical');
+    });
+
+    it('takes the union of distinct findings and orders by severity then key', () => {
+        const env = reconcileFindings([
+            { model: 'a', findings: [raw({ location: 'src/a.ts:1', severity: 'low', category: 'quality' })] },
+            { model: 'b', findings: [raw({ location: 'src/b.ts:9', severity: 'critical', category: 'security' })] },
+        ]);
+        expect(env.findings.map((f) => f.severity)).toEqual(['critical', 'low']);
+        expect(env.findings.map((f) => f.id)).toEqual(['avc-001', 'avc-002']);
+        validateEnvelope(env);
+    });
+
+    it('demotes a lone finding refuted by a majority into false_positives_suppressed', () => {
+        const loneKey = findingKey({ location: 'src/c.ts:5', category: 'security' });
+        const env = reconcileFindings([
+            { model: 'a', findings: [raw({ location: 'src/c.ts:5', category: 'security' })] },
+            { model: 'b', findings: [], refutes: [loneKey] },
+        ]);
+        expect(env.findings).toHaveLength(0);
+        expect(env.false_positives_suppressed).toHaveLength(1);
+        expect(env.false_positives_suppressed[0]!.refuted_by).toEqual(['b']);
+        validateEnvelope(env);
+    });
+
+    it('is deterministic across input order', () => {
+        const a: SkepticReturn = { model: 'a', findings: [raw({ location: 'src/z.ts:1', severity: 'high' })] };
+        const b: SkepticReturn = { model: 'b', findings: [raw({ location: 'src/a.ts:1', severity: 'high', category: 'security' })] };
+        const one = reconcileFindings([a, b]);
+        const two = reconcileFindings([b, a]);
+        expect(one.findings.map((f) => f.location)).toEqual(two.findings.map((f) => f.location));
+        expect(one.findings.map((f) => f.id)).toEqual(two.findings.map((f) => f.id));
+    });
+
+    it('rejects malformed findings from a skeptic', () => {
+        expect(() =>
+            reconcileFindings([{ model: 'a', findings: [raw({ severity: 'nope' as never })] }]),
+        ).toThrow(/severity/);
+    });
+});

package/src/scripts/_lib/adversarial_reconcile.ts

@@ -0,0 +1,187 @@
+/**
+ * Adversarial verification council — reconciliation core (Phase 1).
+ *
+ * Pure, no-I/O, DETERMINISTIC (no Date/random — ids come from sorted key order).
+ * Turns per-skeptic finding lists into one `AdversarialFindings` envelope with
+ * per-finding provenance (which models raised it) and a cross-model confidence
+ * signal. This is the countable heart the ADR mandates lives in TS with tests,
+ * never as LLM-computed prose.
+ *
+ * Contract: it VERIFIES (ranks + annotates findings). It NEVER gates the change
+ * — the panel is advisory only (Hard Floor). "Suppression" of a false positive
+ * demotes a finding into `false_positives_suppressed`; it is never silently
+ * dropped.
+ *
+ * Schema: src/skills/subagent-orchestration/schemas/adversarial-findings.json
+ */
+
+export type Severity = 'critical' | 'high' | 'medium' | 'low';
+export type Confidence = 'high' | 'medium' | 'low';
+
+/** Worst → best; index is the rank used for severity aggregation + sorting. */
+const SEVERITY_ORDER: readonly Severity[] = ['critical', 'high', 'medium', 'low'];
+
+/** A single defect as one skeptic reports it. */
+export interface RawFinding {
+    severity: Severity;
+    category: string;
+    location: string;
+    description: string;
+}
+
+/** One skeptic's return: what it raised, plus keys it examined and judged clean. */
+export interface SkepticReturn {
+    model: string;
+    findings: RawFinding[];
+    /** `findingKey` values this skeptic actively refuted (examined → not a defect). */
+    refutes?: string[];
+}
+
+export interface Finding {
+    id: string;
+    severity: Severity;
+    category: string;
+    location: string;
+    description: string;
+    raised_by: string[];
+    refuted_by: string[];
+    confidence: Confidence;
+}
+
+export interface AdversarialFindings {
+    panel: { models: string[]; skeptic_count: number };
+    findings: Finding[];
+    false_positives_suppressed: Finding[];
+}
+
+/** Dedup key — same location + same category is the same defect. */
+export function findingKey(f: Pick<RawFinding, 'location' | 'category'>): string {
+    return `${f.location.trim()}::${f.category.trim().toLowerCase()}`;
+}
+
+/** Throw on a malformed raw finding — the reconciler refuses garbage in. */
+export function assertValidRawFinding(f: RawFinding): void {
+    if (!SEVERITY_ORDER.includes(f.severity)) {
+        throw new Error(`invalid severity: ${JSON.stringify(f.severity)}`);
+    }
+    for (const [k, v] of Object.entries({ category: f.category, location: f.location, description: f.description })) {
+        if (typeof v !== 'string' || v.trim().length === 0) {
+            throw new Error(`finding.${k} must be a non-empty string`);
+        }
+    }
+}
+
+/** Most-severe (lowest index) of two severities. */
+function moreSevere(a: Severity, b: Severity): Severity {
+    return SEVERITY_ORDER.indexOf(a) <= SEVERITY_ORDER.indexOf(b) ? a : b;
+}
+
+/**
+ * Confidence from corroboration:
+ * - `high`   — raised by >=2 skeptics AND by at least half the panel (quorum).
+ * - `medium` — raised by >=2 (below quorum), OR the lone raiser on a solo panel.
+ * - `low`    — a single raiser on a multi-skeptic panel (uncorroborated doubt).
+ */
+export function severityQuorum(raisedCount: number, refutedCount: number, panelSize: number): Confidence {
+    if (raisedCount >= 2 && raisedCount * 2 >= panelSize) return 'high';
+    if (raisedCount >= 2) return 'medium';
+    if (panelSize === 1 && refutedCount === 0) return 'medium';
+    return 'low';
+}
+
+/**
+ * A finding is a suppressible false positive when a single skeptic raised it and
+ * a strict majority of the OTHER skeptics actively refuted it. Demote, never drop.
+ */
+export function isSuppressedFalsePositive(raisedCount: number, refutedCount: number, panelSize: number): boolean {
+    if (raisedCount !== 1) return false;
+    const others = panelSize - 1;
+    return others > 0 && refutedCount * 2 > others;
+}
+
+interface Aggregate {
+    key: string;
+    severity: Severity;
+    category: string;
+    location: string;
+    description: string;
+    raised_by: string[];
+    refuted_by: string[];
+}
+
+/**
+ * Reconcile per-skeptic returns into one advisory findings envelope.
+ * Deterministic: findings are id'd and ordered by (severity rank, key).
+ */
+export function reconcileFindings(returns: SkepticReturn[]): AdversarialFindings {
+    const models = returns.map((r) => r.model);
+    const skepticCount = returns.length;
+    const byKey = new Map<string, Aggregate>();
+
+    for (const ret of returns) {
+        for (const raw of ret.findings) {
+            assertValidRawFinding(raw);
+            const key = findingKey(raw);
+            const existing = byKey.get(key);
+            if (existing) {
+                existing.severity = moreSevere(existing.severity, raw.severity);
+                if (!existing.raised_by.includes(ret.model)) existing.raised_by.push(ret.model);
+                // Keep the longest description — usually the most informative.
+                if (raw.description.trim().length > existing.description.length) {
+                    existing.description = raw.description.trim();
+                }
+            } else {
+                byKey.set(key, {
+                    key,
+                    severity: raw.severity,
+                    category: raw.category.trim(),
+                    location: raw.location.trim(),
+                    description: raw.description.trim(),
+                    raised_by: [ret.model],
+                    refuted_by: [],
+                });
+            }
+        }
+    }
+
+    // Second pass: attach refutations only to findings that were actually raised.
+    for (const ret of returns) {
+        for (const refutedKey of ret.refutes ?? []) {
+            const agg = byKey.get(refutedKey);
+            if (agg && !agg.raised_by.includes(ret.model) && !agg.refuted_by.includes(ret.model)) {
+                agg.refuted_by.push(ret.model);
+            }
+        }
+    }
+
+    const ordered = [...byKey.values()].sort((a, b) => {
+        const bySeverity = SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity);
+        return bySeverity !== 0 ? bySeverity : a.key.localeCompare(b.key);
+    });
+
+    const findings: Finding[] = [];
+    const suppressed: Finding[] = [];
+    ordered.forEach((agg, i) => {
+        const finding: Finding = {
+            id: `avc-${String(i + 1).padStart(3, '0')}`,
+            severity: agg.severity,
+            category: agg.category,
+            location: agg.location,
+            description: agg.description,
+            raised_by: agg.raised_by,
+            refuted_by: agg.refuted_by,
+            confidence: severityQuorum(agg.raised_by.length, agg.refuted_by.length, skepticCount),
+        };
+        if (isSuppressedFalsePositive(agg.raised_by.length, agg.refuted_by.length, skepticCount)) {
+            suppressed.push(finding);
+        } else {
+            findings.push(finding);
+        }
+    });
+
+    return {
+        panel: { models, skeptic_count: skepticCount },
+        findings,
+        false_positives_suppressed: suppressed,
+    };
+}

package/src/scripts/_lib/verify_budget.ts

@@ -13,7 +13,10 @@
  *   silent pass.
  */
 
-export type VerifyMode = 'deterministic' | 'judge' | 'none';
+// 'council' is the opt-in adversarial-verification-council escalation (Mode 9,
+// ADR-122): default-off, advisory, recorded but never returned by
+// selectVerifyMode — the orchestrator chooses it for high-risk changes.
+export type VerifyMode = 'deterministic' | 'judge' | 'none' | 'council';
 
 /** Max changed-line count (inclusive) that still counts as trivial. */
 export const TRIVIAL_CHANGE_FLOOR = 20;

package/src/scripts/ai_council/prompts.ts

@@ -88,6 +88,13 @@ correctness lens AND a shipping-risk lens:
    Is the blast radius bigger than the title implies?
 5. Reviewer fatigue — is anything in the diff that a tired reviewer
    would rubber-stamp but should not?
+6. Reuse & object-oriented shape — does the diff reinvent a component
+   or abstraction the codebase likely already provides (should compose
+   / reuse instead), and where it adds structure, is the OO shape
+   (encapsulation, composition over inheritance) justified by
+   complexity it removes rather than speculative abstraction? Judge in
+   the codebase's own paradigm — do not push classes onto functional /
+   pipeline code; smallest-change still wins over OO advocacy.
 End with: APPROVE / REQUEST_CHANGES / REJECT, one sentence why, and
 the single highest-leverage change the PR author should make before
 merge.`;