modelrig 0.1.0 → 0.2.0

package/dist/rigindex/fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit.d.ts","sourceRoot":"","sources":["../../src/rigindex/fit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC;qDACqD;AACrD,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqC3E;AAED;;iDAEiD;AACjD,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,GAAG,IAAI,CAIf;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAC1B,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAM/B"}

package/dist/rigindex/fit.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Bradley-Terry fit + frontier anchor — RATIFIED (stop2-architect-review §1):
+ * Hunter's MM algorithm, 400 iterations or convergence, symmetric 0.01
+ * pseudo-wins per ordered pair (keeps saturated all-tie graphs finite and the
+ * graph connected), geometric-mean-normalized per iteration. Anchor:
+ * RigIndex_i = 100 × p_i / GM(basket strengths) — scores >100 are expected
+ * ("above the frontier average").
+ *
+ * Any change to the solver, regularization, or anchor re-opens STOP-2.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSEUDO_WINS = exports.MM_CONVERGENCE = exports.MM_MAX_ITERS = void 0;
+exports.fitBradleyTerry = fitBradleyTerry;
+exports.basketGeometricMean = basketGeometricMean;
+exports.anchorScores = anchorScores;
+exports.MM_MAX_ITERS = 400;
+exports.MM_CONVERGENCE = 1e-10;
+exports.PSEUDO_WINS = 0.01;
+/** Fit BT strengths over the graph's models. Returns modelKey → p, GM-normalized
+ * to 1. Deterministic — no randomness in the fit. */
+function fitBradleyTerry(graph) {
+    const models = graph.models;
+    const n = models.length;
+    if (n === 0)
+        return {};
+    if (n === 1)
+        return { [models[0]]: 1 };
+    // Effective wins with the symmetric pseudo-win regularization: every
+    // ordered pair (i, j), i ≠ j, gains PSEUDO_WINS wins of i over j.
+    const w = models.map((a) => models.map((b) => (a === b ? 0 : graph.wins[a][b] + exports.PSEUDO_WINS)));
+    // Total comparisons per pair (symmetric).
+    const t = models.map((_, i) => models.map((_, j) => w[i][j] + w[j][i]));
+    const totalWins = models.map((_, i) => w[i].reduce((s, x) => s + x, 0));
+    let p = new Array(n).fill(1);
+    for (let iter = 0; iter < exports.MM_MAX_ITERS; iter += 1) {
+        const next = new Array(n);
+        for (let i = 0; i < n; i += 1) {
+            let denom = 0;
+            for (let j = 0; j < n; j += 1) {
+                if (j === i)
+                    continue;
+                denom += t[i][j] / (p[i] + p[j]);
+            }
+            next[i] = denom > 0 ? totalWins[i] / denom : p[i];
+        }
+        // Geometric-mean normalize per iteration (review §1).
+        const gm = Math.exp(next.reduce((s, x) => s + Math.log(x), 0) / n);
+        for (let i = 0; i < n; i += 1)
+            next[i] /= gm;
+        let maxDelta = 0;
+        for (let i = 0; i < n; i += 1) {
+            maxDelta = Math.max(maxDelta, Math.abs(Math.log(next[i] / p[i])));
+        }
+        p = next;
+        if (maxDelta < exports.MM_CONVERGENCE)
+            break;
+    }
+    return Object.fromEntries(models.map((m, i) => [m, p[i]]));
+}
+/** Geometric mean of the basket members' strengths, over the members present
+ * in the fit. Null when NO basket member is in the graph — the subtype cannot
+ * be anchored (and must not publish a score). */
+function basketGeometricMean(strengths, basket) {
+    const present = basket.filter((m) => strengths[m] !== undefined);
+    if (present.length === 0)
+        return null;
+    return Math.exp(present.reduce((s, m) => s + Math.log(strengths[m]), 0) / present.length);
+}
+/** RigIndex_i = 100 × p_i / GM(basket) (review §1). Null when unanchorable. */
+function anchorScores(strengths, basket) {
+    const gm = basketGeometricMean(strengths, basket);
+    if (gm === null)
+        return null;
+    return Object.fromEntries(Object.entries(strengths).map(([m, p]) => [m, (100 * p) / gm]));
+}

package/dist/rigindex/gates.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Believability gates — RATIFIED thresholds (stop2-architect-review §1):
+ *  - min-n: ≥10 DISTINCT outcomes per model per subtype AND ≥2 fixtures.
+ *    Never gate on raw pair counts (publish both; gate on distinct).
+ *  - CI tie-tiers: overlapping CIs render as ONE tier, never a fake ordering.
+ *  - SEPARATION GATE: a subtype publishes a rank view only when its measured
+ *    models form ≥2 CI-distinct tiers; otherwise it renders the all-tie state.
+ * Threshold changes re-open STOP-2.
+ */
+export declare const MIN_DISTINCT_OUTCOMES = 10;
+export declare const MIN_FIXTURES = 2;
+export interface GateInput {
+    readonly model: string;
+    readonly score: number;
+    readonly ci95: readonly [number, number];
+    readonly distinctN: number;
+    readonly fixtures: number;
+}
+export interface GateResult {
+    readonly model: string;
+    readonly gated: boolean;
+    readonly gateReason: string | null;
+    /** 1-based tie-tier among ungated models; null when gated. */
+    readonly tier: number | null;
+}
+/** The min-n verdict for one model — null when it passes. */
+export declare function minNReason(distinctN: number, fixtures: number): string | null;
+/** Interval arithmetic tolerance, in RigIndex points. The MM fit + GM
+ * normalization leave ~1e-13 float dust on saturated scores; a genuine CI
+ * overlap is orders of magnitude wider. One millionth of a point separates
+ * the two regimes cleanly. */
+export declare const TIER_EPSILON = 0.000001;
+/**
+ * Assign tie-tiers to the ungated models: sort by score descending; walking
+ * down, a model joins the current tier iff its CI overlaps the CI of at least
+ * one model already in that tier; otherwise a new tier starts. Overlap chains
+ * deliberately — a bridge model with a wide CI merges the models it straddles
+ * into one tier rather than manufacturing an ordering the data can't support.
+ */
+export declare function assignTiers(inputs: readonly GateInput[]): GateResult[];
+/** Number of CI-distinct tiers among ungated models. */
+export declare function tierCount(results: readonly GateResult[]): number;
+/**
+ * The separation-gate state sentence for a one-tier subtype — authored once
+ * here so the layer and the www render the SAME ratified words (review §1:
+ * "all measured models tie on this task type — no rank distinguishable").
+ * `n` is the total distinct outcomes across the tied models.
+ */
+export declare function allTieSentence(modelCount: number, n: number): string;
+/** The insufficient-data state sentence (min-n gate, review §1). */
+export declare function insufficientSentence(n: number): string;
+//# sourceMappingURL=gates.d.ts.map

package/dist/rigindex/gates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gates.d.ts","sourceRoot":"","sources":["../../src/rigindex/gates.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,6DAA6D;AAC7D,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS7E;AAED;;;8BAG8B;AAC9B,eAAO,MAAM,YAAY,WAAO,CAAC;AA8BjC;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,EAAE,CA4BtE;AAED,wDAAwD;AACxD,wBAAgB,SAAS,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,oEAAoE;AACpE,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/rigindex/gates.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Believability gates — RATIFIED thresholds (stop2-architect-review §1):
+ *  - min-n: ≥10 DISTINCT outcomes per model per subtype AND ≥2 fixtures.
+ *    Never gate on raw pair counts (publish both; gate on distinct).
+ *  - CI tie-tiers: overlapping CIs render as ONE tier, never a fake ordering.
+ *  - SEPARATION GATE: a subtype publishes a rank view only when its measured
+ *    models form ≥2 CI-distinct tiers; otherwise it renders the all-tie state.
+ * Threshold changes re-open STOP-2.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIER_EPSILON = exports.MIN_FIXTURES = exports.MIN_DISTINCT_OUTCOMES = void 0;
+exports.minNReason = minNReason;
+exports.assignTiers = assignTiers;
+exports.tierCount = tierCount;
+exports.allTieSentence = allTieSentence;
+exports.insufficientSentence = insufficientSentence;
+exports.MIN_DISTINCT_OUTCOMES = 10;
+exports.MIN_FIXTURES = 2;
+/** The min-n verdict for one model — null when it passes. */
+function minNReason(distinctN, fixtures) {
+    const reasons = [];
+    if (distinctN < exports.MIN_DISTINCT_OUTCOMES) {
+        reasons.push(`insufficient data (n=${distinctN}, need ≥${exports.MIN_DISTINCT_OUTCOMES} distinct outcomes)`);
+    }
+    if (fixtures < exports.MIN_FIXTURES) {
+        reasons.push(`insufficient fixtures (${fixtures}, need ≥${exports.MIN_FIXTURES})`);
+    }
+    return reasons.length === 0 ? null : reasons.join("; ");
+}
+/** Interval arithmetic tolerance, in RigIndex points. The MM fit + GM
+ * normalization leave ~1e-13 float dust on saturated scores; a genuine CI
+ * overlap is orders of magnitude wider. One millionth of a point separates
+ * the two regimes cleanly. */
+exports.TIER_EPSILON = 1e-6;
+/**
+ * CI overlap = the intersection has length > TIER_EPSILON; intervals equal
+ * within the epsilon (including degenerate zero-variance points, e.g. two
+ * saturated models both pegged at [100, 100] ± float dust) also tie. A
+ * zero-width touch at a boundary point is NOT overlap: the saturated top tier
+ * sits at exactly 100, and an unstable straggler whose 97.5th percentile
+ * grazes 100.0 must not chain the whole board into one tier through that
+ * point (the prototype's reasoning.numeric separation — review §2 — depends
+ * on exactly this).
+ */
+function ciOverlaps(a, b) {
+    if (Math.abs(a[0] - b[0]) <= exports.TIER_EPSILON && Math.abs(a[1] - b[1]) <= exports.TIER_EPSILON) {
+        return true;
+    }
+    if (Math.min(a[1], b[1]) - Math.max(a[0], b[0]) > exports.TIER_EPSILON)
+        return true;
+    // A zero-variance (degenerate) interval strictly INSIDE the other interval's
+    // interior ties — a model whose CI spans [98.5, 101.5] cannot be called
+    // distinct from one pegged at exactly 100. Only a boundary graze separates.
+    const inInterior = (point, range) => point[1] - point[0] <= exports.TIER_EPSILON &&
+        point[0] > range[0] + exports.TIER_EPSILON &&
+        point[1] < range[1] - exports.TIER_EPSILON;
+    return inInterior(a, b) || inInterior(b, a);
+}
+/**
+ * Assign tie-tiers to the ungated models: sort by score descending; walking
+ * down, a model joins the current tier iff its CI overlaps the CI of at least
+ * one model already in that tier; otherwise a new tier starts. Overlap chains
+ * deliberately — a bridge model with a wide CI merges the models it straddles
+ * into one tier rather than manufacturing an ordering the data can't support.
+ */
+function assignTiers(inputs) {
+    const results = [];
+    const ungated = [];
+    for (const input of inputs) {
+        const reason = minNReason(input.distinctN, input.fixtures);
+        if (reason !== null) {
+            results.push({ model: input.model, gated: true, gateReason: reason, tier: null });
+        }
+        else {
+            ungated.push(input);
+        }
+    }
+    const sorted = [...ungated].sort((a, b) => b.score - a.score || (a.model < b.model ? -1 : 1));
+    let tier = 0;
+    let currentTier = [];
+    for (const input of sorted) {
+        if (currentTier.length === 0 ||
+            !currentTier.some((member) => ciOverlaps(member.ci95, input.ci95))) {
+            tier += 1;
+            currentTier = [];
+        }
+        currentTier.push(input);
+        results.push({ model: input.model, gated: false, gateReason: null, tier });
+    }
+    return results;
+}
+/** Number of CI-distinct tiers among ungated models. */
+function tierCount(results) {
+    return results.reduce((max, r) => Math.max(max, r.tier ?? 0), 0);
+}
+/**
+ * The separation-gate state sentence for a one-tier subtype — authored once
+ * here so the layer and the www render the SAME ratified words (review §1:
+ * "all measured models tie on this task type — no rank distinguishable").
+ * `n` is the total distinct outcomes across the tied models.
+ */
+function allTieSentence(modelCount, n) {
+    return `all measured models tie on this task type — no rank distinguishable (${modelCount} models, n=${n} distinct outcomes)`;
+}
+/** The insufficient-data state sentence (min-n gate, review §1). */
+function insufficientSentence(n) {
+    return `insufficient data (n=${n} distinct outcomes)`;
+}

package/dist/rigindex/graph.d.ts

@@ -0,0 +1,31 @@
+/**
+ * RigIndex pairwise graph — the RATIFIED pairing rule (stop2-architect-review
+ * §1, verbatim): outcome per (model, fixture, sample) = `valueAccuracy` if
+ * `schemaConform` else 0 (a non-conformant output failed the task — worst
+ * outcome). On each shared fixture, every cross-sample pair (A_i vs B_j) is a
+ * comparison: win if outcome differs beyond ε; ties count half. A model
+ * missing a fixture contributes NO edge for it (never a zero-outcome edge).
+ *
+ * Any change to this rule re-opens STOP-2. Do not edit without a new
+ * architect sign-off.
+ */
+import type { PairedSample, SubtypeGraph, SubtypeSamples } from "./types";
+/** Float-noise guard only — sampled accuracies are exact fractions, so ε must
+ * never turn a real difference into a tie. */
+export declare const OUTCOME_EPSILON = 1e-9;
+/**
+ * The ratified outcome. A conformant sample carrying a null valueAccuracy
+ * (unscored — does not occur on deterministic-ground-truth fixtures) is
+ * conservatively 0, matching the rule's "failed the task" floor.
+ */
+export declare function outcomeOf(sample: PairedSample): number;
+/**
+ * Build one subtype's pairwise graph from per-(model, fixture) sample lists.
+ * `fixtureDraws` (bootstrap use) lists the fixtures to tally, WITH
+ * multiplicity — a fixture drawn twice contributes its comparisons twice.
+ * Omitted: every fixture any model has, once each.
+ */
+export declare function buildSubtypeGraph(samples: SubtypeSamples, fixtureDraws?: readonly string[]): SubtypeGraph;
+/** Total raw comparisons a model participates in across the graph. */
+export declare function modelPairCount(graph: SubtypeGraph, model: string): number;
+//# sourceMappingURL=graph.d.ts.map

package/dist/rigindex/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/rigindex/graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE1E;8CAC8C;AAC9C,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAGtD;AAOD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,cAAc,EACvB,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,GAC/B,YAAY,CAkEd;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAOzE"}

package/dist/rigindex/graph.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * RigIndex pairwise graph — the RATIFIED pairing rule (stop2-architect-review
+ * §1, verbatim): outcome per (model, fixture, sample) = `valueAccuracy` if
+ * `schemaConform` else 0 (a non-conformant output failed the task — worst
+ * outcome). On each shared fixture, every cross-sample pair (A_i vs B_j) is a
+ * comparison: win if outcome differs beyond ε; ties count half. A model
+ * missing a fixture contributes NO edge for it (never a zero-outcome edge).
+ *
+ * Any change to this rule re-opens STOP-2. Do not edit without a new
+ * architect sign-off.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTCOME_EPSILON = void 0;
+exports.outcomeOf = outcomeOf;
+exports.buildSubtypeGraph = buildSubtypeGraph;
+exports.modelPairCount = modelPairCount;
+/** Float-noise guard only — sampled accuracies are exact fractions, so ε must
+ * never turn a real difference into a tie. */
+exports.OUTCOME_EPSILON = 1e-9;
+/**
+ * The ratified outcome. A conformant sample carrying a null valueAccuracy
+ * (unscored — does not occur on deterministic-ground-truth fixtures) is
+ * conservatively 0, matching the rule's "failed the task" floor.
+ */
+function outcomeOf(sample) {
+    if (sample.schemaConform !== true)
+        return 0;
+    return sample.valueAccuracy ?? 0;
+}
+/** Unordered pair key, order-stable. */
+function pairKey(a, b) {
+    return a < b ? `${a}|${b}` : `${b}|${a}`;
+}
+/**
+ * Build one subtype's pairwise graph from per-(model, fixture) sample lists.
+ * `fixtureDraws` (bootstrap use) lists the fixtures to tally, WITH
+ * multiplicity — a fixture drawn twice contributes its comparisons twice.
+ * Omitted: every fixture any model has, once each.
+ */
+function buildSubtypeGraph(samples, fixtureDraws) {
+    const models = Object.keys(samples).sort();
+    const fixtures = fixtureDraws ??
+        [...new Set(models.flatMap((m) => Object.keys(samples[m])))].sort();
+    const wins = {};
+    for (const m of models) {
+        wins[m] = {};
+        for (const other of models)
+            if (other !== m)
+                wins[m][other] = 0;
+    }
+    const pairCounts = {};
+    const distinctN = {};
+    const fixtureSet = {};
+    for (const m of models) {
+        distinctN[m] = 0;
+        fixtureSet[m] = new Set();
+    }
+    // Distinct outcomes / fixture coverage count each real (model, fixture)
+    // ONCE regardless of bootstrap multiplicity — n describes the data held,
+    // not the resampling plan.
+    for (const m of models) {
+        for (const [fixtureId, list] of Object.entries(samples[m])) {
+            if (list.length === 0)
+                continue;
+            distinctN[m] += list.length;
+            fixtureSet[m].add(fixtureId);
+        }
+    }
+    for (const fixtureId of fixtures) {
+        for (let i = 0; i < models.length; i += 1) {
+            const a = models[i];
+            const aSamples = samples[a][fixtureId];
+            if (aSamples === undefined || aSamples.length === 0)
+                continue; // no edge
+            for (let j = i + 1; j < models.length; j += 1) {
+                const b = models[j];
+                const bSamples = samples[b][fixtureId];
+                if (bSamples === undefined || bSamples.length === 0)
+                    continue; // no edge
+                let aWins = 0;
+                let bWins = 0;
+                let ties = 0;
+                for (const sa of aSamples) {
+                    const oa = outcomeOf(sa);
+                    for (const sb of bSamples) {
+                        const ob = outcomeOf(sb);
+                        if (oa > ob + exports.OUTCOME_EPSILON)
+                            aWins += 1;
+                        else if (ob > oa + exports.OUTCOME_EPSILON)
+                            bWins += 1;
+                        else
+                            ties += 1;
+                    }
+                }
+                wins[a][b] += aWins + ties / 2;
+                wins[b][a] += bWins + ties / 2;
+                const key = pairKey(a, b);
+                pairCounts[key] = (pairCounts[key] ?? 0) + aWins + bWins + ties;
+            }
+        }
+    }
+    return {
+        models,
+        wins,
+        pairCounts,
+        distinctN,
+        fixtureCount: Object.fromEntries(models.map((m) => [m, fixtureSet[m].size])),
+    };
+}
+/** Total raw comparisons a model participates in across the graph. */
+function modelPairCount(graph, model) {
+    let total = 0;
+    for (const [key, count] of Object.entries(graph.pairCounts)) {
+        const [a, b] = key.split("|");
+        if (a === model || b === model)
+            total += count;
+    }
+    return total;
+}

package/dist/rigindex/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * RigIndex orchestration — pure entry point over per-subtype paired samples.
+ * The whole pipeline per subtype: pairwise graph (ratified pairing rule) →
+ * Hunter MM Bradley-Terry fit → 2026-Q3 basket anchor → hierarchical
+ * bootstrap CIs → gates (min-n, tie-tiers, separation). All models in the
+ * graph shape the fit (pooled comparisons); the GATES decide what publishes —
+ * a gated model's score is null, never a confident number on thin evidence.
+ */
+import type { RigIndexLayer, RigIndexSubtype, SubtypeSamples } from "./types";
+export interface ComputeOptions {
+    readonly reps?: number;
+    readonly seed?: number;
+}
+export declare const DEFAULT_SEED = 20260813;
+export declare function computeSubtype(samples: SubtypeSamples, basket: readonly string[], options?: ComputeOptions): RigIndexSubtype;
+export declare function computeRigIndexLayer(subtypeSamples: Readonly<Record<string, SubtypeSamples>>, basket: {
+    readonly version: string;
+    readonly members: readonly string[];
+}, meta: {
+    readonly asOf: string;
+    readonly source: string;
+}, options?: ComputeOptions): RigIndexLayer;
+//# sourceMappingURL=index.d.ts.map

package/dist/rigindex/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rigindex/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAYH,OAAO,KAAK,EACV,aAAa,EAEb,eAAe,EACf,cAAc,EACf,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC,wBAAgB,cAAc,CAC5B,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,cAAmB,GAC3B,eAAe,CAgFjB;AAED,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,EACxD,MAAM,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EACzE,IAAI,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACxD,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAiBf"}

package/dist/rigindex/index.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * RigIndex orchestration — pure entry point over per-subtype paired samples.
+ * The whole pipeline per subtype: pairwise graph (ratified pairing rule) →
+ * Hunter MM Bradley-Terry fit → 2026-Q3 basket anchor → hierarchical
+ * bootstrap CIs → gates (min-n, tie-tiers, separation). All models in the
+ * graph shape the fit (pooled comparisons); the GATES decide what publishes —
+ * a gated model's score is null, never a confident number on thin evidence.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SEED = void 0;
+exports.computeSubtype = computeSubtype;
+exports.computeRigIndexLayer = computeRigIndexLayer;
+const graph_1 = require("./graph");
+const fit_1 = require("./fit");
+const bootstrap_1 = require("./bootstrap");
+const gates_1 = require("./gates");
+exports.DEFAULT_SEED = 20260813;
+function computeSubtype(samples, basket, options = {}) {
+    const reps = options.reps ?? bootstrap_1.BOOTSTRAP_REPS;
+    const seed = options.seed ?? exports.DEFAULT_SEED;
+    const graph = (0, graph_1.buildSubtypeGraph)(samples);
+    const scores = (0, fit_1.anchorScores)((0, fit_1.fitBradleyTerry)(graph), basket);
+    const cis = scores === null
+        ? {}
+        : (0, bootstrap_1.bootstrapCis)(samples, basket, reps, (0, bootstrap_1.mulberry32)(seed));
+    const gateInputs = [];
+    const noCi = [];
+    for (const model of graph.models) {
+        const score = scores?.[model];
+        const ci = cis[model];
+        if (score === undefined || ci === undefined) {
+            noCi.push(model);
+            continue;
+        }
+        gateInputs.push({
+            model,
+            score,
+            ci95: ci,
+            distinctN: graph.distinctN[model],
+            fixtures: graph.fixtureCount[model],
+        });
+    }
+    const gateResults = (0, gates_1.assignTiers)(gateInputs);
+    const byModel = new Map(gateResults.map((r) => [r.model, r]));
+    const scoreOf = new Map(gateInputs.map((g) => [g.model, g]));
+    const models = {};
+    let ungatedCount = 0;
+    let ungatedN = 0;
+    for (const model of graph.models) {
+        const gate = byModel.get(model);
+        const input = scoreOf.get(model);
+        const gated = gate === undefined ? true : gate.gated;
+        if (!gated) {
+            ungatedCount += 1;
+            ungatedN += graph.distinctN[model];
+        }
+        models[model] = {
+            score: gated ? null : (input?.score ?? null),
+            ci95: gated ? null : (input?.ci95 ?? null),
+            tier: gate?.tier ?? null,
+            distinct_n: graph.distinctN[model],
+            pair_count: (0, graph_1.modelPairCount)(graph, model),
+            fixtures: graph.fixtureCount[model],
+            // Probe-only launch (review §1): every comparison is probe-derived.
+            provenance: {
+                probe_derived_pairs: (0, graph_1.modelPairCount)(graph, model),
+                community_pairs: 0,
+            },
+            gated,
+            gate_reason: gate?.gateReason ??
+                (gate === undefined ? "unanchorable or no bootstrap distribution" : null),
+        };
+    }
+    const tiers = (0, gates_1.tierCount)(gateResults);
+    const totalN = Object.values(graph.distinctN).reduce((s, n) => s + n, 0);
+    // The separation gate (review §1): <2 rankable models is an insufficiency,
+    // exactly one CI-distinct tier is the honest all-tie state.
+    let state;
+    let stateDetail;
+    if (ungatedCount < 2) {
+        state = "insufficient";
+        stateDetail = (0, gates_1.insufficientSentence)(totalN);
+    }
+    else if (tiers < 2) {
+        state = "all-tie";
+        stateDetail = (0, gates_1.allTieSentence)(ungatedCount, ungatedN);
+    }
+    else {
+        state = "rank";
+        stateDetail = null;
+    }
+    return { state, state_detail: stateDetail, tiers, models };
+}
+function computeRigIndexLayer(subtypeSamples, basket, meta, options = {}) {
+    const subtypes = {};
+    for (const subtype of Object.keys(subtypeSamples).sort()) {
+        subtypes[subtype] = computeSubtype(subtypeSamples[subtype], basket.members, options);
+    }
+    return {
+        as_of: meta.asOf,
+        source: meta.source,
+        basket_version: basket.version,
+        basket_members: [...basket.members],
+        bootstrap: {
+            reps: options.reps ?? bootstrap_1.BOOTSTRAP_REPS,
+            seed: options.seed ?? exports.DEFAULT_SEED,
+            method: "hierarchical-fixture-then-per-model-fixture-sample",
+        },
+        subtypes,
+    };
+}

package/dist/rigindex/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * RigIndex shared types (Cycle 4 — rigindex-scoring/spec.md, math ratified in
+ * stop2-architect-review.md §1). The scoring layer is PURE: it consumes only
+ * per-sample paired outcomes from probe result files — never marginal
+ * statistics, telemetry, or observed health (the RigIndex wall, spec §6).
+ */
+/** The two per-sample fields the pairing rule reads — and the ONLY signal the
+ * scoring layer may consume (rigindex-wall.test.ts asserts cost/latency/parse
+ * fields never move a score). */
+export interface PairedSample {
+    readonly schemaConform: boolean | null;
+    readonly valueAccuracy: number | null;
+}
+/** modelKey → fixtureId → that model's samples on the fixture. A model
+ * missing a fixture simply has no key for it (and contributes NO edge). */
+export type SubtypeSamples = Readonly<Record<string, Readonly<Record<string, readonly PairedSample[]>>>>;
+/** Pairwise tallies for one subtype. `wins[a][b]` counts a's effective wins
+ * over b — ties already folded in at half (review §1: ties count half). */
+export interface SubtypeGraph {
+    readonly models: readonly string[];
+    /** wins[a][b] = wins of a over b + 0.5 per tie. */
+    readonly wins: Readonly<Record<string, Readonly<Record<string, number>>>>;
+    /** Raw cross-sample comparison count per unordered model pair, summed —
+     * published beside distinct_n, never gated on (review §1 min-n). */
+    readonly pairCounts: Readonly<Record<string, number>>;
+    /** Distinct per-(model,fixture,sample) outcomes per model — the min-n
+     * gate's n (review §1: gate on distinct outcomes, not pairs). */
+    readonly distinctN: Readonly<Record<string, number>>;
+    /** Fixtures each model contributed samples on (min-n needs ≥2). */
+    readonly fixtureCount: Readonly<Record<string, number>>;
+}
+/** One model's published entry in layers/rigindex.json. */
+export interface RigIndexModelEntry {
+    readonly score: number | null;
+    readonly ci95: readonly [number, number] | null;
+    /** 1-based tie-tier (1 = top). Null when the model is min-n gated. */
+    readonly tier: number | null;
+    readonly distinct_n: number;
+    readonly pair_count: number;
+    readonly fixtures: number;
+    /** Probe-only launch: every edge is probe-derived (review §1 source
+     * diversity — labeled single source, community edges arrive later). */
+    readonly provenance: {
+        readonly probe_derived_pairs: number;
+        readonly community_pairs: number;
+    };
+    readonly gated: boolean;
+    readonly gate_reason: string | null;
+}
+/** A subtype's publish state after ALL gates (review §1):
+ * - "rank"        — ≥2 CI-distinct tiers among ungated models → rank view
+ * - "all-tie"     — one tier: "all measured models tie…" (separation gate)
+ * - "insufficient"— no (or one) model passes min-n; nothing rankable. */
+export type SubtypeState = "rank" | "all-tie" | "insufficient";
+export interface RigIndexSubtype {
+    readonly state: SubtypeState;
+    /** The honest display sentence for a non-rank state (gate rendering is
+     * authored ONCE here so the www renders the same words the layer states). */
+    readonly state_detail: string | null;
+    readonly tiers: number;
+    readonly models: Readonly<Record<string, RigIndexModelEntry>>;
+}
+export interface RigIndexLayer {
+    readonly as_of: string;
+    /** Single-source label (review §1): probe-derived, no community edges yet. */
+    readonly source: string;
+    readonly basket_version: string;
+    readonly basket_members: readonly string[];
+    readonly bootstrap: {
+        readonly reps: number;
+        readonly seed: number;
+        readonly method: "hierarchical-fixture-then-per-model-fixture-sample";
+    };
+    readonly subtypes: Readonly<Record<string, RigIndexSubtype>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/rigindex/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/rigindex/types.ts"],"names":[],"mappings":"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"}

package/dist/rigindex/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * RigIndex shared types (Cycle 4 — rigindex-scoring/spec.md, math ratified in
+ * stop2-architect-review.md §1). The scoring layer is PURE: it consumes only
+ * per-sample paired outcomes from probe result files — never marginal
+ * statistics, telemetry, or observed health (the RigIndex wall, spec §6).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });