@aiwg/cli 2026.9.21 → 2026.10.0

package/dist/src/gates/report.js

@@ -0,0 +1,102 @@
+import { canonicalJson } from '../security/artifact-trust.js';
+import { artifactDigest } from '../decision/validate.js';
+import { evaluateGates, maxOutcome } from './evaluate.js';
+import { validateGateDocument } from './schema.js';
+/**
+ * Validates a gate report against its trusted inputs. The report is re-derived
+ * by re-running the pure evaluator from the same trusted inputs (binding,
+ * registry, holdout, metrics, upstream) and must be byte-identical: the
+ * expected digest must equal the parsed digest. A forged report that rewrites
+ * evidence and reseals the digest still fails, because re-derivation from
+ * trusted inputs reproduces the honest bytes. Returns reasons instead of
+ * throwing so callers can log them.
+ */
+export function validateGateReport(report, input) {
+    const reasons = [];
+    let parsed;
+    try {
+        parsed = validateGateDocument(report);
+    }
+    catch (error) {
+        return { valid: false, reasons: [`report-schema:${error instanceof Error ? error.message : 'invalid'}`] };
+    }
+    const { digest, ...fields } = parsed;
+    if (artifactDigest(fields) !== digest)
+        reasons.push('report-digest-mismatch');
+    if (artifactDigest(input.binding) !== parsed.binding.digest)
+        reasons.push('report-binding-mismatch');
+    if (input.trustedBindingDigest !== parsed.binding.digest)
+        reasons.push('report-binding-untrusted');
+    if (input.holdout === undefined || input.holdout === null
+        || input.holdout.frozenDigest !== parsed.binding.digest) {
+        reasons.push('report-holdout-mismatch');
+    }
+    if (input.holdout !== undefined
+        && input.holdout !== null) {
+        const sealed = input.holdout;
+        if (sealed.digest !== parsed.holdout?.digest
+            || sealed.firstAccessedAt !== parsed.holdout?.firstAccessedAt) {
+            reasons.push('report-holdout-mismatch');
+        }
+    }
+    if (parsed.holdout?.digest === undefined
+        || parsed.holdout?.frozenDigest !== parsed.binding.digest) {
+        reasons.push('report-holdout-mismatch');
+    }
+    for (const pin of input.binding.spec.packs) {
+        const found = parsed.packs.find(candidate => candidate.id === pin.id);
+        if (found === undefined || found.digest !== pin.digest || found.resolvedDigest !== pin.resolvedDigest) {
+            reasons.push(`report-pack-mismatch:${pin.id}`);
+        }
+    }
+    if (artifactDigest(input.metrics) !== parsed.metricsDigest
+        // Bundle-provider sections are reproduced by isolated re-run, so the
+        // caller-asserted document is not the evaluated one; re-derivation below
+        // is authoritative for those bindings.
+        && (input.providerRuntime === undefined
+            || !input.binding.spec.metricProviders.some(pin => typeof pin.codeDigest === 'string'))) {
+        reasons.push('report-metrics-mismatch');
+    }
+    // The report records which floors governed it (R2): an applied digest or an
+    // explicit opt-out marker. The input must say the same; re-derivation below
+    // additionally reproduces the distinction byte-identically.
+    const expectedFloors = input.floors === 'none-explicit-opt-out'
+        ? 'opt-out' : `applied:${artifactDigest(input.floors)}`;
+    const reportedFloors = parsed.floors.mode === 'applied' ? `applied:${parsed.floors.digest}` : 'opt-out';
+    if (reportedFloors !== expectedFloors)
+        reasons.push('report-floors-mismatch');
+    if ((input.upstream?.digest ?? null) !== (parsed.upstream?.digest ?? null)) {
+        reasons.push('report-upstream-mismatch');
+    }
+    let expected;
+    try {
+        expected = evaluateGates({ ...input, now: parsed.evaluatedAt });
+    }
+    catch (error) {
+        return { valid: false, reasons: [...reasons, `report-reevaluation:${error instanceof Error ? error.message : 'refused'}`] };
+    }
+    // Byte-identical re-derivation: the evaluator is deterministic, so the honest
+    // report's canonical bytes must match exactly. Comparing digests (which hash
+    // the canonical bytes) is equivalent and cheaper than a byte comparison; the
+    // canonical comparison is the independent second route.
+    if (expected.digest !== parsed.digest
+        || canonicalJson(stripDigest(expected)) !== canonicalJson(fields)) {
+        reasons.push('report-reevaluation-mismatch');
+    }
+    if (expected.decision !== parsed.decision)
+        reasons.push('report-decision-mismatch');
+    const components = [
+        ...parsed.gateEvidence.map(entry => entry.outcome),
+        parsed.ceilings.packOutcome, parsed.ceilings.upstreamCeiling, parsed.ceilings.bindingCeiling,
+    ];
+    if (maxOutcome(parsed.decision, maxOutcome(...components)) !== parsed.decision) {
+        reasons.push('report-upgrades-component');
+    }
+    return { valid: reasons.length === 0, reasons };
+}
+function stripDigest(report) {
+    const { digest: _dropped, ...fields } = report;
+    void _dropped;
+    return fields;
+}
+//# sourceMappingURL=report.js.map

package/dist/src/gates/schema.js

@@ -0,0 +1,56 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+export class GateSchemaError extends Error {
+    errors;
+    constructor(message, errors = []) {
+        super(message);
+        this.errors = errors;
+        this.name = 'GateSchemaError';
+    }
+}
+const schemaFiles = {
+    GatePack: 'GatePack.v1alpha1.schema.json',
+    GateBinding: 'GateBinding.v1alpha1.schema.json',
+    GateReport: 'GateReport.v1alpha1.schema.json',
+};
+let validators = null;
+function schemaRoot() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [resolve(here, '../../schemas/gates'), resolve(here, '../../../schemas/gates')];
+    const found = candidates.find(candidate => existsSync(resolve(candidate, schemaFiles.GatePack)));
+    if (!found)
+        throw new GateSchemaError('Gate schema directory is unavailable');
+    return found;
+}
+function getValidators() {
+    if (validators)
+        return validators;
+    const ajv = new Ajv2020({ strict: false, allErrors: true });
+    addFormats(ajv);
+    validators = new Map();
+    for (const [kind, filename] of Object.entries(schemaFiles)) {
+        const schema = JSON.parse(readFileSync(resolve(schemaRoot(), filename), 'utf8'));
+        validators.set(`gates.aiwg.io/v1alpha1:${kind}`, ajv.compile(schema));
+    }
+    return validators;
+}
+const message = (errors) => errors?.map(error => `${error.instancePath || '/'} ${error.message}`).join('; ') ?? 'unknown schema error';
+/** Closed-schema validation for a gates document. Returns the document unchanged when valid. */
+export function validateGateDocument(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new GateSchemaError('Gate document must be an object');
+    }
+    const kind = value.kind;
+    const version = value.apiVersion;
+    const key = `${version}:${kind}`;
+    const validate = kind ? getValidators().get(key) : undefined;
+    if (!validate)
+        throw new GateSchemaError(`Unsupported gate kind/version '${key}'`);
+    if (!validate(value))
+        throw new GateSchemaError(`${kind} schema validation failed: ${message(validate.errors)}`, validate.errors ?? []);
+    return value;
+}
+//# sourceMappingURL=schema.js.map

package/dist/src/gates/stats/binomial.js

@@ -0,0 +1,26 @@
+import { PairedDifferenceError } from './error.js';
+import { isCount, twoSidedZ } from './normal.js';
+/**
+ * Two-sided Wilson score interval for a binomial proportion at `levelBps` (5001..9998), so each bound
+ * is a one-sided (10000 - levelBps) / 20000 bound. Counts must satisfy 0 <= events <= n and n > 0.
+ */
+export function wilsonScoreInterval(input) {
+    const z = twoSidedZ(input?.levelBps);
+    const { events, n } = input;
+    if (!isCount(events) || !isCount(n) || n === 0 || events > n) {
+        throw new PairedDifferenceError('wilson interval requires integer counts with 0 <= events <= n and n > 0');
+    }
+    return wilsonScore(events, n, z);
+}
+export function wilson95(errors, n) {
+    // 95% normal quantile; finite-sample Wilson interval for binomial events.
+    return wilsonScore(errors, n, 1.959963984540054);
+}
+export function wilsonScore(errors, n, z) {
+    const rate = errors / n;
+    const denominator = 1 + z * z / n;
+    const center = (rate + z * z / (2 * n)) / denominator;
+    const margin = z * Math.sqrt(rate * (1 - rate) / n + z * z / (4 * n * n)) / denominator;
+    return [Math.max(0, center - margin), Math.min(1, center + margin)];
+}
+//# sourceMappingURL=binomial.js.map

package/dist/src/gates/stats/bootstrap.js

@@ -0,0 +1,62 @@
+import { PairedDifferenceError } from './error.js';
+import { twoSidedZ } from './normal.js';
+import { toBpsInterval } from './paired.js';
+/** Deterministic 32-bit mulberry32 stream. */
+function mulberry32(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return (t ^ (t >>> 14)) >>> 0;
+    };
+}
+/** Unbiased index in [0, n): reject draws in the incomplete top block of the 2^32 range. */
+function uniformIndex(next, n) {
+    const limit = Math.floor(0x100000000 / n) * n;
+    for (;;) {
+        const draw = next();
+        if (draw < limit)
+            return draw % n;
+    }
+}
+/**
+ * Seeded percentile bootstrap for the mean of bounded per-pair differences (candidate minus
+ * baseline) on the proportion scale, so 1.0 = 10000 bps. Bounds must lie within [-1, 1].
+ * Order statistics are chosen outward and each tail must hold at least 5 resamples.
+ */
+export function pairedMeanDifferenceBootstrap(input) {
+    twoSidedZ(input?.levelBps);
+    const { differences, levelBps, seed, resamples, bounds } = input;
+    if (!Array.isArray(bounds) || bounds.length !== 2 || !bounds.every(Number.isFinite)
+        || bounds[0] < -1 || bounds[1] > 1 || bounds[0] >= bounds[1]) {
+        throw new PairedDifferenceError('bounds must be finite with -1 <= min < max <= 1');
+    }
+    if (!Array.isArray(differences) || differences.length < 2) {
+        throw new PairedDifferenceError('bootstrap requires at least two paired differences');
+    }
+    if (differences.some(value => typeof value !== 'number' || !Number.isFinite(value) || value < bounds[0] || value > bounds[1])) {
+        throw new PairedDifferenceError('paired differences must be finite and within bounds');
+    }
+    if (!Number.isSafeInteger(seed) || seed < 0 || seed > 0xffffffff) {
+        throw new PairedDifferenceError('seed must be an unsigned 32-bit integer');
+    }
+    const tail = Number.isSafeInteger(resamples) ? Math.floor(resamples * (10000 - levelBps) / 20000) : 0;
+    if (!Number.isSafeInteger(resamples) || resamples > 1_000_000 || tail < 5) {
+        throw new PairedDifferenceError('resamples must be an integer <= 1000000 leaving at least 5 per tail');
+    }
+    const n = differences.length;
+    const next = mulberry32(seed);
+    const means = new Float64Array(resamples);
+    for (let r = 0; r < resamples; r++) {
+        let sum = 0;
+        for (let i = 0; i < n; i++)
+            sum += differences[uniformIndex(next, n)];
+        means[r] = sum / n;
+    }
+    means.sort();
+    const estimate = differences.reduce((sum, value) => sum + value, 0) / n;
+    return toBpsInterval(Math.min(means[tail - 1], estimate), Math.max(means[resamples - tail], estimate), estimate, n, 'percentile-bootstrap');
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/src/gates/stats/clopper-pearson.js

@@ -0,0 +1,95 @@
+import { PairedDifferenceError } from './error.js';
+import { isCount } from './normal.js';
+/**
+ * Exact binomial tail P(X >= events) at proportion p, summed in log space with
+ * precomputed log factorials: linear in n and free of underflow for large n.
+ */
+function upperTail(events, n, p) {
+    if (p <= 0)
+        return events <= 0 ? 1 : 0;
+    if (p >= 1)
+        return events <= n ? 1 : 0;
+    const logP = Math.log(p);
+    const logQ = Math.log(1 - p);
+    const logFact = [0];
+    for (let i = 1; i <= n; i++)
+        logFact.push(logFact[i - 1] + Math.log(i));
+    let peak = -Infinity;
+    const terms = [];
+    for (let k = events; k <= n; k++) {
+        const term = logFact[n] - logFact[k] - logFact[n - k]
+            + k * logP + (n - k) * logQ;
+        terms.push(term);
+        if (term > peak)
+            peak = term;
+    }
+    let sum = 0;
+    for (const term of terms)
+        sum += Math.exp(term - peak);
+    return Math.min(1, sum * Math.exp(peak));
+}
+/**
+ * Exact Clopper-Pearson interval for a binomial proportion. `levelBps` (5001..9998) is the
+ * two-sided level; each tail holds (10000 - levelBps) / 20000. `sided` selects a one-sided
+ * bound at the same level instead: 'lower' returns [bound, 1] and 'upper' returns [0, bound].
+ * Counts must satisfy 0 <= events <= n and n > 0. Bounds are inverted by bisection on the
+ * exact binomial tail, so the coverage is at least the nominal level by construction.
+ */
+export function clopperPearsonInterval(input) {
+    if (!input || typeof input !== 'object')
+        throw new PairedDifferenceError('clopper-pearson interval input is required');
+    const { events, n, levelBps, sided } = input;
+    if (!isCount(events) || !isCount(n) || n === 0 || events > n) {
+        throw new PairedDifferenceError('clopper-pearson interval requires integer counts with 0 <= events <= n and n > 0');
+    }
+    if (!Number.isSafeInteger(levelBps) || levelBps <= 5000 || levelBps >= 9999) {
+        throw new PairedDifferenceError('levelBps must be an integer strictly between 5000 and 9999');
+    }
+    const side = sided ?? 'two-sided';
+    if (side !== 'two-sided' && side !== 'lower' && side !== 'upper') {
+        throw new PairedDifferenceError('clopper-pearson sided must be two-sided, lower or upper');
+    }
+    const level = levelBps;
+    const tail = (side === 'two-sided' ? (10000 - level) / 20000 : (10000 - level) / 10000);
+    // P(X >= events | p) rises from 0 at p=0 to 1 at p=1. Each loop keeps `below`
+    // under the root and returns it, so the lower bound rounds outward (down).
+    const solveTail = (target) => {
+        let below = 0;
+        let above = 1;
+        for (let i = 0; i < 200; i++) {
+            const mid = (below + above) / 2;
+            if (mid === below || mid === above)
+                break;
+            if (upperTail(events, n, mid) > target)
+                above = mid;
+            else
+                below = mid;
+        }
+        return below;
+    };
+    // P(X <= events | p) = 1 - P(X >= events + 1 | p) falls from 1 to 0. Each loop
+    // keeps `above` over the root and returns it, so the upper bound rounds outward (up).
+    const solveLowerTail = (target) => {
+        let below = 0;
+        let above = 1;
+        for (let i = 0; i < 200; i++) {
+            const mid = (below + above) / 2;
+            if (mid === below || mid === above)
+                break;
+            if (1 - upperTail(events + 1, n, mid) > target)
+                below = mid;
+            else
+                above = mid;
+        }
+        return above;
+    };
+    if (side === 'lower')
+        return { lower: events === 0 ? 0 : solveTail(tail), upper: 1 };
+    if (side === 'upper')
+        return { lower: 0, upper: events === n ? 1 : solveLowerTail(tail) };
+    return {
+        lower: events === 0 ? 0 : solveTail(tail),
+        upper: events === n ? 1 : solveLowerTail(tail),
+    };
+}
+//# sourceMappingURL=clopper-pearson.js.map

package/dist/src/gates/stats/digest.js

@@ -0,0 +1,26 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from '../../security/artifact-trust.js';
+export const evidenceDigestModes = (modes) => modes ?? ['canonical'];
+/** Canonical-JSON sha256 digest. All new gates and qualification evidence uses this. */
+export function canonicalSha256(value) {
+    return `sha256:${createHash('sha256').update(canonicalJson(value)).digest('hex')}`;
+}
+/**
+ * Versioned legacy mode: pre-migration `quality.ts`/`release.ts` digests hashed
+ * `JSON.stringify` output, which depends on key order. Accepts exactly those bytes
+ * so existing evidence still verifies without re-pinning (operator default).
+ */
+export function legacySha256(value) {
+    return `sha256:${createHash('sha256').update(JSON.stringify(value)).digest('hex')}`;
+}
+/** Returns the first matching mode, or null when neither digest matches. Null digests never match. Canonical-only by default; legacy requires an explicit allowlist. */
+export function matchEvidenceDigest(value, digest, modes = ['canonical']) {
+    if (typeof digest !== 'string')
+        return null;
+    for (const mode of evidenceDigestModes(modes)) {
+        if ((mode === 'canonical' ? canonicalSha256(value) : legacySha256(value)) === digest)
+            return mode;
+    }
+    return null;
+}
+//# sourceMappingURL=digest.js.map

package/dist/src/gates/stats/error.js

@@ -0,0 +1,5 @@
+/** Shared error for malformed statistics inputs. All stats helpers fail closed by throwing this. */
+export class PairedDifferenceError extends Error {
+    constructor(message) { super(message); this.name = 'PairedDifferenceError'; }
+}
+//# sourceMappingURL=error.js.map

package/dist/src/gates/stats/index.js

@@ -0,0 +1,9 @@
+export { PairedDifferenceError } from './error.js';
+export { normalQuantile } from './normal.js';
+export { wilsonScoreInterval } from './binomial.js';
+export { clopperPearsonInterval } from './clopper-pearson.js';
+export { pairedBinaryDifferenceInterval, pairedNonInferiority } from './paired.js';
+export { pairedMeanDifferenceBootstrap } from './bootstrap.js';
+export { freezeQualificationSplit, verifyQualificationSplits } from './splits.js';
+export { canonicalSha256, legacySha256, matchEvidenceDigest } from './digest.js';
+//# sourceMappingURL=index.js.map

package/dist/src/gates/stats/normal.js

@@ -0,0 +1,35 @@
+import { PairedDifferenceError } from './error.js';
+/**
+ * Acklam's rational approximation to the standard normal quantile (relative error < 1.15e-9).
+ * Throws for p outside the open interval (0, 1).
+ */
+export function normalQuantile(p) {
+    if (!Number.isFinite(p) || p <= 0 || p >= 1)
+        throw new PairedDifferenceError('normal quantile requires 0 < p < 1');
+    const a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
+        1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00];
+    const b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
+        6.680131188771972e+01, -1.328068155288572e+01];
+    const c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
+        -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00];
+    const d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00];
+    const tail = (q) => (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5])
+        / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+    if (p < 0.02425)
+        return tail(Math.sqrt(-2 * Math.log(p)));
+    if (p > 1 - 0.02425)
+        return -tail(Math.sqrt(-2 * Math.log(1 - p)));
+    const q = p - 0.5;
+    const r = q * q;
+    return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q
+        / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+}
+/** Two-sided level in bps; only 5001..9998 are accepted so neither tail is empty or trivial. */
+export function twoSidedZ(levelBps) {
+    if (!Number.isSafeInteger(levelBps) || levelBps <= 5000 || levelBps >= 9999) {
+        throw new PairedDifferenceError('levelBps must be an integer strictly between 5000 and 9999');
+    }
+    return normalQuantile((10000 + levelBps) / 20000);
+}
+export const isCount = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+//# sourceMappingURL=normal.js.map

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

@@ -0,0 +1,120 @@
+import { wilsonScore } from './binomial.js';
+import { PairedDifferenceError } from './error.js';
+import { isCount, twoSidedZ } from './normal.js';
+function pairedCells(counts) {
+    if (!counts || typeof counts !== 'object')
+        throw new PairedDifferenceError('paired counts are required');
+    const full = ['both', 'candidateOnly', 'baselineOnly', 'neither'].some(key => Object.hasOwn(counts, key));
+    const discordant = ['b', 'c', 'n'].some(key => Object.hasOwn(counts, key));
+    if (full === discordant)
+        throw new PairedDifferenceError('provide either the full paired table or discordant b, c and n');
+    if ('both' in counts) {
+        const { both, candidateOnly, baselineOnly, neither } = counts;
+        if (![both, candidateOnly, baselineOnly, neither].every(isCount)) {
+            throw new PairedDifferenceError('paired cell counts must be non-negative safe integers');
+        }
+        const n = both + candidateOnly + baselineOnly + neither;
+        if (n === 0 || !Number.isSafeInteger(n))
+            throw new PairedDifferenceError('paired table requires n > 0');
+        return { e: both, f: candidateOnly, g: baselineOnly, h: neither, n };
+    }
+    const { b, c, n } = counts;
+    if (![b, c, n].every(isCount) || n === 0 || b + c > n) {
+        throw new PairedDifferenceError('discordant counts require non-negative integers with b + c <= n and n > 0');
+    }
+    return { e: null, f: b, g: c, h: null, n };
+}
+// Outward rounding: a reported bound is never tighter than the computed one.
+export const toBpsInterval = (low, high, estimate, n, method) => {
+    if (![low, high, estimate].every(Number.isFinite) || low > estimate || estimate > high) {
+        throw new PairedDifferenceError('paired interval computation was not finite and ordered');
+    }
+    return {
+        lowerBps: Math.max(-10000, Math.floor(low * 10000)), upperBps: Math.min(10000, Math.ceil(high * 10000)),
+        estimateBps: Math.round(estimate * 10000), n, method,
+    };
+};
+/**
+ * Two-sided score interval for p_candidate - p_baseline from paired binary outcomes.
+ * `newcombe-10` (default): Newcombe (1998) method 10, square-and-add of continuity-free Wilson
+ * intervals for both marginals with phi numerator replaced by max(eh - fg - n/2, 0) when eh > fg.
+ * `tango`: Tango (1998) asymptotic score interval, inverted by bisection; needs only b, c and n.
+ */
+export function pairedBinaryDifferenceInterval(input) {
+    const z = twoSidedZ(input?.levelBps);
+    const { e, f, g, h, n } = pairedCells(input.counts);
+    const estimate = (f - g) / n;
+    const method = input.method ?? 'newcombe-10';
+    if (method === 'tango') {
+        const [low, high] = tangoInterval(f, g, n, z);
+        return toBpsInterval(low, high, estimate, n, 'tango-score');
+    }
+    if (method !== 'newcombe-10')
+        throw new PairedDifferenceError('unknown paired interval method');
+    if (e === null || h === null)
+        throw new PairedDifferenceError('newcombe method 10 requires the full paired table');
+    const p1 = (e + f) / n;
+    const p2 = (e + g) / n;
+    const [l1, u1] = wilsonScore(e + f, n, z);
+    const [l2, u2] = wilsonScore(e + g, n, z);
+    const denominator = Math.sqrt((e + f) * (g + h) * (e + g) * (f + h));
+    const cross = e * h - f * g;
+    const phi = denominator === 0 ? 0 : (cross > 0 ? Math.max(cross - n / 2, 0) : cross) / denominator;
+    const delta = Math.sqrt(Math.max(0, (p1 - l1) ** 2 - 2 * phi * (p1 - l1) * (u2 - p2) + (u2 - p2) ** 2));
+    const epsilon = Math.sqrt(Math.max(0, (u1 - p1) ** 2 - 2 * phi * (u1 - p1) * (p2 - l2) + (p2 - l2) ** 2));
+    return toBpsInterval(Math.max(-1, estimate - delta), Math.min(1, estimate + epsilon), estimate, n, 'newcombe-hybrid-score');
+}
+function tangoInterval(b, c, n, z) {
+    // Tango's statistic decreases in delta; the restricted MLE of the baseline-only cell is closed form.
+    const statistic = (delta) => {
+        const B = -b - c + (2 * n - b + c) * delta;
+        const q21 = (Math.sqrt(Math.max(0, B * B + 8 * n * c * delta * (1 - delta))) - B) / (4 * n);
+        const numerator = b - c - n * delta;
+        const variance = n * (2 * q21 + delta * (1 - delta));
+        if (numerator === 0)
+            return 0;
+        return variance > 0 ? numerator / Math.sqrt(variance) : numerator * Infinity;
+    };
+    const estimate = (b - c) / n;
+    // Each search keeps `outer` outside the acceptance region and returns it, so rounding widens.
+    const search = (outer, inner, rejects) => {
+        for (let i = 0; i < 200; i++) {
+            const mid = (outer + inner) / 2;
+            if (mid === outer || mid === inner)
+                break;
+            if (rejects(statistic(mid)))
+                outer = mid;
+            else
+                inner = mid;
+        }
+        return outer;
+    };
+    return [
+        estimate === -1 ? -1 : search(-1, estimate, t => t > z),
+        estimate === 1 ? 1 : search(1, estimate, t => t < -z),
+    ];
+}
+/**
+ * One-sided non-inferiority read of a two-sided interval. `marginBps` is a non-positive integer:
+ * -250 lets the candidate be at most 2.5 points worse than the baseline. Non-inferior only when
+ * lowerBps >= marginBps; malformed intervals are 'insufficient', never a pass.
+ */
+export function pairedNonInferiority(input) {
+    const marginBps = input?.marginBps;
+    if (!Number.isSafeInteger(marginBps) || marginBps > 0 || marginBps < -10000) {
+        throw new PairedDifferenceError('marginBps must be an integer in [-10000, 0]');
+    }
+    const interval = input.interval;
+    const valid = !!interval && typeof interval === 'object'
+        && [interval.lowerBps, interval.upperBps, interval.estimateBps].every(value => Number.isSafeInteger(value)
+            && value >= -10000 && value <= 10000)
+        && Number.isSafeInteger(interval.n) && interval.n > 0
+        && interval.lowerBps <= interval.estimateBps && interval.estimateBps <= interval.upperBps
+        && ['newcombe-hybrid-score', 'tango-score', 'percentile-bootstrap'].includes(interval.method);
+    if (!valid)
+        return { decision: 'insufficient', reason: 'invalid-interval' };
+    return interval.lowerBps >= marginBps
+        ? { decision: 'non-inferior', reason: 'lower-bound-at-or-above-margin' }
+        : { decision: 'not-non-inferior', reason: 'lower-bound-below-margin' };
+}
+//# sourceMappingURL=paired.js.map

package/dist/src/gates/stats/splits.js

@@ -0,0 +1,30 @@
+import { canonicalSha256 } from './digest.js';
+function digestIds(ids) {
+    return canonicalSha256([...ids].sort());
+}
+/** Hash the exact membership set; duplicate, empty and overlapping IDs fail closed. */
+export function freezeQualificationSplit(name, ids) {
+    if (!ids.length || ids.some(id => !id.trim()) || new Set(ids).size !== ids.length) {
+        throw new Error('qualification split requires unique nonempty IDs');
+    }
+    return { name, ids: [...ids].sort(), digest: digestIds(ids) };
+}
+export function verifyQualificationSplits(splits) {
+    if (splits.length !== 3 || new Set(splits.map(split => split.name)).size !== 3
+        || splits.some(split => !['tuning', 'calibration', 'test'].includes(split.name))) {
+        throw new Error('qualification requires tuning, calibration and test splits');
+    }
+    const all = new Set();
+    for (const split of splits) {
+        if (!split.ids.length || split.ids.some(id => typeof id !== 'string' || !id.trim())
+            || new Set(split.ids).size !== split.ids.length || split.digest !== digestIds(split.ids)) {
+            throw new Error('qualification split digest or membership mismatch');
+        }
+        for (const id of split.ids) {
+            if (all.has(id))
+                throw new Error('qualification splits overlap');
+            all.add(id);
+        }
+    }
+}
+//# sourceMappingURL=splits.js.map

package/dist/src/gates/types.js

@@ -0,0 +1,8 @@
+export const GATES_API_VERSION = 'gates.aiwg.io/v1alpha1';
+/**
+ * Qualifies a pack parameter for a binding: `<packId>.<param>`. Parameters are
+ * namespaced per pack so two packs declaring the same short name can never
+ * collide or silently merge in a binding.
+ */
+export const qualifyGateParameter = (packId, name) => `${packId}.${name}`;
+//# sourceMappingURL=types.js.map

package/dist/src/governance/redaction.js

@@ -20,7 +20,17 @@ const BUILTIN_SENSITIVE_KEY = /(?:^|[_-])(?:authorization|auth[_-]?header|cookie
 const BUILTIN_PATTERNS = [
     {
         id: 'private-key',
-        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/g,
+        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----/g,
+    },
+    {
+        id: 'private-key',
+        // Bounded fallback for truncated input that never reaches an END marker.
+        // Only the header plus up to 100 complete base64 body lines are consumed,
+        // so following prose is preserved: a line extends the match only when the
+        // whole line is base64, an RFC 1421 header (e.g. `Proc-Type: 4,ENCRYPTED`,
+        // `DEK-Info: …`) or blank, so legacy encrypted bodies are still covered. Runs after the terminated pattern above, which
+        // already consumed every block that has an END marker.
+        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----(?:[ \t]+[A-Za-z0-9+/=]{4,}[ \t]*(?=\r?\n|$))?(?:\r?\n(?:[ \t]*[A-Za-z0-9+/=]{4,}[ \t]*|[A-Za-z][A-Za-z0-9-]*:[^\r\n]*|[ \t]*)(?=\r?\n|$)){0,100}/g,
     },
     {
         id: 'authorization-header',
@@ -61,7 +71,7 @@ const BUILTIN_PATTERNS = [
     },
     {
         id: 'provider-token',
-        pattern: /\b(?:sk-(?:proj-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA)[A-Za-z0-9._~+/=-]{6,}\b/g,
+        pattern: /\b(?:sk-(?:proj-)?|[sr]k_(?:live|test)_|gh[pousr]_|github_pat_|xox[baprs]-|whsec_|glpat-|AKIA)[A-Za-z0-9._~+/=-]{6,}\b/g,
     },
     {
         id: 'bearer-token',
@@ -163,11 +173,11 @@ function decodedSecretClass(value) {
         const decoded = Buffer.from(value, 'base64').toString('utf8');
         if (!decoded || decoded.includes('\uFFFD'))
             return null;
-        if (/-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/.test(decoded))
+        if (/-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----/.test(decoded))
             return 'encoded-private-key';
         if (/(?:api[_-]?key|token|password|passwd|secret|authorization)\s*[:=]/i.test(decoded))
             return 'encoded-secret';
-        if (/(?:sk-(?:proj-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA)[A-Za-z0-9._~+/=-]{6,}/.test(decoded))
+        if (/(?:sk-(?:proj-)?|[sr]k_(?:live|test)_|gh[pousr]_|github_pat_|xox[baprs]-|whsec_|glpat-|AKIA)[A-Za-z0-9._~+/=-]{6,}/.test(decoded))
             return 'encoded-secret';
         return null;
     }