@aiwg/cli 2026.9.24 → 2026.10.1

package/dist/src/gates/providers/paired.js

@@ -0,0 +1,52 @@
+import { providerSourceDigest, requireRecords } from './types.js';
+/**
+ * Core paired provider: builds the 2x2 paired table per slice from candidate/baseline
+ * records. Powers `paired-difference` (newcombe, tango; non-inferiority, superiority) gates.
+ */
+export const pairedProvider = {
+    id: 'test.paired/v1',
+    version: '1.0.0',
+    description: 'Per-slice paired candidate/baseline tables.',
+    metrics: {
+        'contrast': { kind: 'paired', description: 'Paired 2x2 table per slice.' },
+    },
+    sourceDigest: providerSourceDigest({ id: 'test.paired/v1', version: '1.0.0',
+        metrics: { 'contrast': { kind: 'paired' } } }),
+    compute(records) {
+        const rows = requireRecords(records, 'paired');
+        const cells = {};
+        for (const row of rows) {
+            if (!row || typeof row.slice !== 'string' || !row.slice.trim()
+                || typeof row.candidate !== 'boolean' || typeof row.baseline !== 'boolean') {
+                throw new Error('paired records require a nonempty slice and boolean candidate/baseline');
+            }
+            const cell = cells[row.slice] ?? { both: 0, candidateOnly: 0, baselineOnly: 0, neither: 0 };
+            if (row.candidate && row.baseline)
+                cell.both++;
+            else if (row.candidate)
+                cell.candidateOnly++;
+            else if (row.baseline)
+                cell.baselineOnly++;
+            else
+                cell.neither++;
+            cells[row.slice] = cell;
+        }
+        const bySlice = {};
+        for (const [slice, cell] of Object.entries(cells)) {
+            bySlice[slice] = { n: cell.both + cell.candidateOnly + cell.baselineOnly + cell.neither, paired: { ...cell } };
+        }
+        const total = { both: 0, candidateOnly: 0, baselineOnly: 0, neither: 0 };
+        for (const cell of Object.values(cells)) {
+            total.both += cell.both;
+            total.candidateOnly += cell.candidateOnly;
+            total.baselineOnly += cell.baselineOnly;
+            total.neither += cell.neither;
+        }
+        const pooled = Object.keys(bySlice).length
+            ? { n: total.both + total.candidateOnly + total.baselineOnly + total.neither, paired: total }
+            : null;
+        return { version: '1.0.0', sourceDigest: pairedProvider.sourceDigest,
+            metrics: { 'contrast': { bySlice, pooled } } };
+    },
+};
+//# sourceMappingURL=paired.js.map

package/dist/src/gates/providers/proportion.js

@@ -0,0 +1,60 @@
+import { providerSourceDigest, requireRecords } from './types.js';
+const VOCABULARY = {
+    'false-ready': { kind: 'proportion', description: 'False-ready events per slice.' },
+    'coverage': { kind: 'proportion', description: 'Accepted (advisory-ready) share per slice.' },
+};
+/**
+ * Tallies binary records per metric and slice. Records outside `allowed`
+ * throw: undeclared metric names fail closed at compute time.
+ */
+export function tallyProportionRecords(rows, allowed, label) {
+    const tables = new Map();
+    for (const row of rows) {
+        if (!row || typeof row.slice !== 'string' || !row.slice.trim() || typeof row.event !== 'boolean'
+            || typeof row.metric !== 'string' || !allowed.has(row.metric)) {
+            throw new Error(`${label} records require a nonempty slice, a declared metric and a boolean event`);
+        }
+        const table = tables.get(row.metric) ?? new Map();
+        const current = table.get(row.slice) ?? { n: 0, events: 0 };
+        table.set(row.slice, { n: current.n + 1, events: current.events + (row.event ? 1 : 0) });
+        tables.set(row.metric, table);
+    }
+    return tables;
+}
+/** Builds one metric series per tally table, pooling slices into an overall observation. */
+export function proportionSeries(tables, names) {
+    const series = (table) => {
+        const bySlice = {};
+        for (const [slice, counts] of table ?? [])
+            bySlice[slice] = { ...counts };
+        const pooled = Object.values(bySlice).reduce((sum, observation) => ({
+            n: (sum?.n ?? 0) + observation.n,
+            events: (sum?.events ?? 0) + observation.events,
+        }), Object.keys(bySlice).length ? { n: 0, events: 0 } : null);
+        return { bySlice, pooled };
+    };
+    return Object.fromEntries(names.map(name => [name, series(tables.get(name))]));
+}
+/**
+ * Core proportion provider with a fixed metric vocabulary: each record names
+ * its metric, and undeclared metric names fail closed at compute time. Powers
+ * `interval-bound` (wilson, clopper-pearson), `count-max` / `count-min` and
+ * `minimum-n` gates.
+ */
+export const proportionProvider = {
+    id: 'test.proportion/v1',
+    version: '1.0.0',
+    description: 'Per-slice event counts from binary records with a fixed vocabulary.',
+    metrics: {
+        'false-ready': { ...VOCABULARY['false-ready'] },
+        'coverage': { ...VOCABULARY.coverage },
+    },
+    sourceDigest: providerSourceDigest({ id: 'test.proportion/v1', version: '1.0.0', metrics: VOCABULARY }),
+    compute(records) {
+        const rows = requireRecords(records, 'proportion');
+        const tables = tallyProportionRecords(rows, new Set(['false-ready', 'coverage']), 'proportion');
+        return { version: '1.0.0', sourceDigest: proportionProvider.sourceDigest,
+            metrics: proportionSeries(tables, ['false-ready', 'coverage']) };
+    },
+};
+//# sourceMappingURL=proportion.js.map

package/dist/src/gates/providers/registry.js

@@ -0,0 +1,40 @@
+import { isLoaderIssuedProvider } from './loader.js';
+/** Registry of metric providers. Unknown or duplicate ids fail at load; nothing resolves by default. */
+export class MetricProviderRegistry {
+    providers = new Map();
+    register(provider) {
+        if (!provider || typeof provider.id !== 'string' || !provider.id.trim()
+            || typeof provider.version !== 'string' || !provider.version.trim()
+            || typeof provider.sourceDigest !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(provider.sourceDigest)
+            || !provider.metrics || typeof provider.metrics !== 'object'
+            || typeof provider.compute !== 'function') {
+            throw new Error('metric provider registration requires id, version, sourceDigest, metrics and compute');
+        }
+        if (provider.codeDigest !== undefined
+            && (typeof provider.codeDigest !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(provider.codeDigest))) {
+            throw new Error(`metric provider ${provider.id} code digest is unknown`);
+        }
+        // C3: a code-digest (bundle) provider registers only as the exact frozen
+        // object the bundle loader issued after its allowlist check. Copies and
+        // hand-made objects carrying the same fields cannot bypass the allowlist.
+        if (provider.codeDigest !== undefined && !isLoaderIssuedProvider(provider)) {
+            throw new Error(`metric provider ${provider.id} carries a code digest but was not issued by the bundle loader: refusing registration`);
+        }
+        if (this.providers.has(provider.id))
+            throw new Error(`duplicate metric provider: ${provider.id}`);
+        this.providers.set(provider.id, provider);
+    }
+    get(id) {
+        const provider = typeof id === 'string' ? this.providers.get(id) : undefined;
+        if (!provider)
+            throw new Error(`unknown metric provider: ${String(id)}`);
+        return provider;
+    }
+    has(id) {
+        return typeof id === 'string' && this.providers.has(id);
+    }
+    ids() {
+        return [...this.providers.keys()].sort();
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/src/gates/providers/scalar.js

@@ -0,0 +1,41 @@
+import { providerSourceDigest, requireRecords } from './types.js';
+/**
+ * Core scalar provider: per-slice mean, extrema and raw differences from numeric records.
+ * Powers `value-threshold` gates (mean) and `bootstrap-bound` gates (differences).
+ */
+export const scalarProvider = {
+    id: 'test.scalar/v1',
+    version: '1.0.0',
+    description: 'Per-slice mean and raw values from numeric records.',
+    metrics: {
+        'measurement': { kind: 'scalar', description: 'Mean value per slice.' },
+        'delta': { kind: 'differences', description: 'Raw per-record values per slice.' },
+    },
+    sourceDigest: providerSourceDigest({ id: 'test.scalar/v1', version: '1.0.0',
+        metrics: { 'measurement': { kind: 'scalar' }, 'delta': { kind: 'differences' } } }),
+    compute(records) {
+        const rows = requireRecords(records, 'scalar');
+        const groups = new Map();
+        for (const row of rows) {
+            if (!row || typeof row.slice !== 'string' || !row.slice.trim()
+                || typeof row.value !== 'number' || !Number.isFinite(row.value)) {
+                throw new Error('scalar records require a nonempty slice and a finite value');
+            }
+            groups.set(row.slice, [...(groups.get(row.slice) ?? []), row.value]);
+        }
+        const measurement = {};
+        const delta = {};
+        for (const [slice, values] of groups) {
+            measurement[slice] = { n: values.length, value: values.reduce((sum, value) => sum + value, 0) / values.length };
+            delta[slice] = { n: values.length, differences: [...values] };
+        }
+        const all = [...groups.values()].flat();
+        const mean = (values) => values.length
+            ? { n: values.length, value: values.reduce((sum, value) => sum + value, 0) / values.length } : null;
+        return { version: '1.0.0', sourceDigest: scalarProvider.sourceDigest, metrics: {
+                'measurement': { bySlice: measurement, pooled: mean(all) },
+                'delta': { bySlice: delta, pooled: all.length ? { n: all.length, differences: all } : null },
+            } };
+    },
+};
+//# sourceMappingURL=scalar.js.map

package/dist/src/gates/providers/screening.js

@@ -0,0 +1,53 @@
+import { providerSourceDigest, requireRecords } from './types.js';
+import { collectAttestations } from './evidence.js';
+import { proportionSeries, tallyProportionRecords } from './proportion.js';
+const PROPORTIONS = ['false-ready', 'false-support', 'coverage', 'accuracy'];
+const VOCABULARY = {
+    'false-ready': { kind: 'proportion', description: 'False-ready events per slice: advisory-ready with non-ready gold.' },
+    'false-support': { kind: 'proportion', description: 'False-support events per citation slice: accepted support with non-support gold.' },
+    'coverage': { kind: 'proportion', description: 'Advisory-ready share per slice; the always-review reference rate is 0.' },
+    'accuracy': { kind: 'proportion', description: 'Joint candidate correctness per slice: route matches gold readiness and support.' },
+    'calibration': { kind: 'evidence', description: 'Staged D09 calibration artifact binding for the scored phase.' },
+};
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+/**
+ * Core screening provider behind the `aiwg:decision-engine/absolute-screening`
+ * pack. Binary records tally into per-slice proportion series; calibration
+ * attestations collect into the pooled evidence observation. Powers
+ * `interval-bound` (wilson), `count-max`, `minimum-n` and `evidence` gates.
+ */
+export const screeningProvider = {
+    id: 'decision.screening/v1',
+    version: '1.0.0',
+    description: 'SDLC evidence-screening proportions with the staged-calibration attestation.',
+    metrics: {
+        'false-ready': { ...VOCABULARY['false-ready'] },
+        'false-support': { ...VOCABULARY['false-support'] },
+        'coverage': { ...VOCABULARY.coverage },
+        'accuracy': { ...VOCABULARY.accuracy },
+        'calibration': { ...VOCABULARY.calibration },
+    },
+    sourceDigest: providerSourceDigest({ id: 'decision.screening/v1', version: '1.0.0', metrics: VOCABULARY }),
+    compute(records) {
+        const rows = requireRecords(records, 'screening');
+        const binary = [];
+        const attestations = [];
+        for (const row of rows) {
+            const hasMetric = isRecord(row) && typeof row.metric === 'string';
+            const hasId = isRecord(row) && typeof row.id === 'string';
+            if (hasMetric === hasId) {
+                throw new Error('screening records are either binary {slice, metric, event} or attestations {id, passed}');
+            }
+            if (hasMetric)
+                binary.push(row);
+            else
+                attestations.push(row);
+        }
+        const tables = tallyProportionRecords(binary, new Set(PROPORTIONS), 'screening');
+        const metrics = proportionSeries(tables, [...PROPORTIONS]);
+        const pooled = { available: collectAttestations(attestations, 'screening') };
+        return { version: '1.0.0', sourceDigest: screeningProvider.sourceDigest,
+            metrics: { ...metrics, 'calibration': { bySlice: {}, pooled } } };
+    },
+};
+//# sourceMappingURL=screening.js.map

package/dist/src/gates/providers/types.js

@@ -0,0 +1,25 @@
+import { artifactDigest } from '../../decision/validate.js';
+export function providerSourceDigest(descriptor) {
+    return artifactDigest(descriptor);
+}
+/** Fail-closed record guard shared by core providers. */
+export function requireRecords(records, label) {
+    if (!Array.isArray(records))
+        throw new Error(`${label} records must be an array`);
+    return records;
+}
+export function pooledFromSlices(slices) {
+    const observations = Object.values(slices);
+    if (!observations.length)
+        return null;
+    const ns = observations.map(observation => observation.n);
+    if (ns.some(n => n === null || n === undefined))
+        return null;
+    const total = ns.reduce((sum, n) => sum + n, 0);
+    const sum = (pick) => {
+        const values = observations.map(pick);
+        return values.every(value => typeof value === 'number') ? values.reduce((a, b) => a + b, 0) : null;
+    };
+    return { n: total, events: sum(observation => observation.events), value: null };
+}
+//# sourceMappingURL=types.js.map