@tachikomagundam/abathur 0.2.5 → 0.2.7

package/dist/core/stats.js

@@ -26,15 +26,39 @@
 //  - Pareto over (trainScore, tokens, wallS); budget-truncated generations
 //    (complete:false) never enter the set.
 //
+// ACCEPTANCE SEMANTICS (2026-09-24 redesign; design doc lives in the target
+// genome repo's evidence folder, not shipped here): when EvaluateInput.bank
+// carries the historical per-unit variance bank, precision/regression checks
+// price NOISE
+// with bank σ instead of per-arm t(df=n−1) CIs (the campaign-9/10 resolution
+// floor: t(0.05,1)=12.706 turned a 2-point sample into a 1.5883 half-width).
+// A val unit with bank σ clears when P(Δ ≤ −halfWidth) < q_pair AND the
+// acceptance band Z(q)·σ/√n_candidate ≤ halfWidth; the aggregate additionally
+// requires P(gain shift > 0) = Φ(gain/SE) ≥ q_pair, q_pair = 1−(1−ACCEPT_Q)/nPairs.
+// EVERY fail-closed rule ABOVE the bank path is untouched and can never be
+// bypassed by it: budget⇒inconclusive, one-sided n<2⇒indeterminate,
+// both-unmeasured⇒symmetric exclusion. A unit the bank cannot price falls back
+// to the exact legacy t-CI line; a null/absent bank reproduces the pre-2026-09-24
+// gate verbatim. minEffect 0.1 / halfWidth 0.15 point semantics stand.
+//
 // The inverse Student-t lives in stats-math.ts and the Pareto ranking in
 // stats-pareto.ts; both are re-exported here so the public surface of this
 // module — the one todos 9/10/12 consume — is unchanged. Accuracy: |t − table|
 // < 1e-3 for the t-distribution rows checked in stats.test.ts (df=1..30, α=0.05).
 import { EXIT_BLOCKED, EXIT_CANNOT_ANSWER, EXIT_OK } from "../exit.js";
 /** Per-unit replicate scores (train and val units alike). */
-import { studentTQuantile } from "./stats-math.js";
+import { studentTQuantile, normalCdf, normalQuantile } from "./stats-math.js";
 import { seededRandom, paretoFrontier } from "./stats-pareto.js";
-export { studentTQuantile, seededRandom, paretoFrontier };
+export { studentTQuantile, normalCdf, normalQuantile, seededRandom, paretoFrontier };
+/** Nomination acceptance probability (per finalist pair after Bonferroni). */
+export const ACCEPT_Q = 0.9;
+/** q_pair = 1 − (1 − ACCEPT_Q)/nPairs — Bonferroni on the acceptance ERROR rate. */
+export function bonferroniQ(nPairs) {
+    if (!Number.isInteger(nPairs) || nPairs < 1) {
+        throw new RangeError(`bonferroniQ: nPairs=${String(nPairs)} must be an integer >= 1`);
+    }
+    return Math.min(0.9999, 1 - (1 - ACCEPT_Q) / nPairs);
+}
 /** Family-wise alpha across finalist pairs (bonferroniAlpha divides it). */
 export const FAMILY_ALPHA = 0.05;
 /** Verdict → process exit code. inconclusive = 2 (cannot answer), never 0. */
@@ -165,7 +189,14 @@ export function evaluate(input) {
     const candKept = candidate.units.filter((u) => !excluded.has(u.unitId));
     const incKept = incumbent.units.filter((u) => !excluded.has(u.unitId));
     const candByUnitKept = new Map(candKept.map((u) => [u.unitId, u]));
-    // 3) Per-val-unit comparisons + the two precision gates.
+    // 3) Per-val-unit comparisons + the two precision gates. With a bank that
+    //    knows the unit, acceptance semantics (see module header) replace the
+    //    per-arm t-CI machinery FOR THAT UNIT ONLY; bank-unknown units keep the
+    //    legacy lines verbatim. The fail-closed rules above run before and
+    //    independently of any bank.
+    const bank = input.bank ?? null;
+    const qPair = bonferroniQ(nPairs);
+    const acceptanceUnits = [];
     const unitComparisons = [];
     for (const [unitId, incUnit] of incByUnit) {
         if (incUnit.split !== "val" || excluded.has(unitId))
@@ -173,30 +204,73 @@ export function evaluate(input) {
         const candUnit = candByUnitKept.get(unitId);
         if (candUnit === undefined)
             continue; // excluded/unreachable
-        const cs = summarizeUnit(candUnit.scores, alpha);
         const incumbentMean = summarizeUnit(incUnit.scores).mean;
+        const cs = summarizeUnit(candUnit.scores, alpha);
         const delta = cs.mean - incumbentMean;
-        unitComparisons.push({
-            unitId,
-            candidateMean: cs.mean,
-            incumbentMean,
-            ciHalfWidth: cs.ciHalfWidth,
-            delta,
-            ciPasses: cs.ciHalfWidth <= stats.halfWidth,
-            passes: delta >= -cs.ciHalfWidth, // ties allowed
-        });
-        if (cs.ciHalfWidth > stats.halfWidth) {
-            failures.push(`CI half-width ${fmt(cs.ciHalfWidth)} > halfWidth ${fmt(stats.halfWidth)} on unit '${unitId}'`);
+        const banked = bank?.get(unitId) ?? null;
+        if (banked === null) {
+            unitComparisons.push({
+                unitId,
+                candidateMean: cs.mean,
+                incumbentMean,
+                ciHalfWidth: cs.ciHalfWidth,
+                delta,
+                ciPasses: cs.ciHalfWidth <= stats.halfWidth,
+                passes: delta >= -cs.ciHalfWidth, // ties allowed
+            });
+            if (cs.ciHalfWidth > stats.halfWidth) {
+                failures.push(`CI half-width ${fmt(cs.ciHalfWidth)} > halfWidth ${fmt(stats.halfWidth)} on unit '${unitId}'`);
+            }
+            if (delta < -cs.ciHalfWidth) {
+                failures.push(`regression on unit '${unitId}': delta ${fmt(delta)} < ${fmt(-cs.ciHalfWidth)} (mean ${fmt(cs.mean)} < ${fmt(incumbentMean)} - ${fmt(cs.ciHalfWidth)})`);
+            }
+            continue;
+        }
+        const se = banked.sigma * Math.sqrt(1 / candUnit.scores.length + 1 / incUnit.scores.length);
+        const band = (normalQuantile(qPair) * banked.sigma) / Math.sqrt(candUnit.scores.length);
+        const pRegression = se === 0 ? (delta <= -stats.halfWidth ? 1 : 0) : normalCdf((-stats.halfWidth - delta) / se);
+        const ciPasses = band <= stats.halfWidth;
+        const passes = pRegression < qPair; // ties at −halfWidth sit at Φ(0)=0.5 < q ⇒ still pass
+        unitComparisons.push({ unitId, candidateMean: cs.mean, incumbentMean, ciHalfWidth: band, delta, ciPasses, passes });
+        acceptanceUnits.push({ unitId, sigma: banked.sigma, df: banked.df, delta, se, band, pRegression });
+        if (!ciPasses) {
+            failures.push(`acceptance band ${fmt(band)} > halfWidth ${fmt(stats.halfWidth)} on unit '${unitId}' (bank sigma ${fmt(banked.sigma)}, df ${String(banked.df)})`);
         }
-        if (delta < -cs.ciHalfWidth) {
-            failures.push(`regression on unit '${unitId}': delta ${fmt(delta)} < ${fmt(-cs.ciHalfWidth)} (mean ${fmt(cs.mean)} < ${fmt(incumbentMean)} - ${fmt(cs.ciHalfWidth)})`);
+        else if (!passes) {
+            failures.push(`regression on unit '${unitId}': delta ${fmt(delta)} — P(Δ ≤ −${fmt(stats.halfWidth)}) = ${fmt(pRegression)} ≥ q ${fmt(qPair)} (bank sigma ${fmt(banked.sigma)})`);
         }
     }
-    // 4) Effect-size floor on the aggregate gain (shared, symmetric pool).
+    // 4) Effect-size floor on the aggregate gain (shared, symmetric pool) —
+    //    unchanged — plus the acceptance gate: when the bank can price EVERY
+    //    unit of the gain pool, nomination additionally requires P(Δ>0) ≥ q.
+    //    A bank-priced point mass exactly at 0 (se=0, gain=0) fails (pShift=0):
+    //    demonstrated-identical arms are never nominated on a tie.
     const gain = aggregateScore(candKept) - aggregateScore(incKept);
     if (gain < stats.minEffect) {
         failures.push(`gain ${fmt(gain)} < minEffect ${fmt(stats.minEffect)}`);
     }
+    let gainSe = null;
+    let pShift = null;
+    if (bank !== null) {
+        const train = candKept.filter((u) => u.split === "train");
+        const pool = train.length > 0 ? train : candKept;
+        const incCounts = new Map(incKept.map((u) => [u.unitId, u.scores.length]));
+        const priced = pool.map((u) => bank.get(u.unitId) ?? null);
+        if (priced.every((s) => s !== null)) {
+            const k = pool.length;
+            let variance = 0;
+            pool.forEach((u, index) => {
+                const s = priced[index];
+                variance += ((s.sigma * s.sigma) * (1 / u.scores.length + 1 / (incCounts.get(u.unitId) ?? 0))) / (k * k);
+            });
+            gainSe = Math.sqrt(variance);
+            pShift = gainSe === 0 ? (gain > 0 ? 1 : 0) : normalCdf(gain / gainSe);
+            if (pShift < qPair) {
+                failures.push(`acceptance: P(gain shift > 0) = ${fmt(pShift)} < q ${fmt(qPair)} (se ${fmt(gainSe)}, gain ${fmt(gain)})`);
+            }
+        }
+    }
     const verdict = failures.length === 0 ? "nominated" : "culled";
-    return { ...base, verdict, exitCode: needsExit(verdict), gain, unitComparisons, failures };
+    const acceptance = bank === null ? undefined : { q: qPair, gainSe, pShift, units: acceptanceUnits };
+    return { ...base, verdict, exitCode: needsExit(verdict), gain, unitComparisons, failures, ...(acceptance === undefined ? {} : { acceptance }) };
 }

package/dist/core/worktree.js

@@ -23,7 +23,7 @@ export { snapshotCommit } from "./snapshot.js";
 export { INCUMBENT_BRANCH, fastForwardIncumbent } from "./incumbent.js";
 const DAY_MS = 86_400_000;
 /** Fixed committer identity for sealed generations (repo config is never trusted or touched). */
-const SEAL_IDENTITY = ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local"];
+const SEAL_IDENTITY = ["-c", "user.name=abathur", "-c", "user.email=agent@host.example"];
 // ------------------------------------------------------------------ openGenome
 /** Porcelain v1 with -z: "XY path" records; rename/copy records carry the source as an extra NUL field. */
 function parsePorcelain(raw) {

package/dist/genomes/toy-smoke/init.mjs

@@ -47,7 +47,7 @@ if (!existsSync(path.join(dest, ".git"))) {
   git(["add", "-A"]);
   // identity pinned via -c BEFORE the subcommand (global gitconfig immune;
   // `git init` itself rejects -c after the subcommand — learnings todo 3).
-  git(["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "commit", "-m", "toy-smoke fixture seed"]);
+  git(["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "commit", "-m", "toy-smoke fixture seed"]);
 }
 
 process.stdout.write(`${dest}\n`);

package/dist/test/bundle.test.js

@@ -81,7 +81,7 @@ async function bundleFixture(t, opts = {}) {
         writeFileSync(path.join(repo, "genome.jsonc"), `${JSON.stringify({ ...spec, bundle: { maskLiterals: [...opts.maskLiterals] } }, null, 2)}\n`, "utf8");
         // commit the edit: export self-describes from the gen COMMIT tree, so the
         // registry spec and the committed spec must agree by construction.
-        gitC(repo, "-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "commit", "-am", "bundle: declare maskLiterals");
+        gitC(repo, "-c", "user.name=abathur", "-c", "user.email=agent@host.example", "commit", "-am", "bundle: declare maskLiterals");
     }
     registerGenome(configDir, path.join(repo, "genome.jsonc"));
     const entry = requireGenomesByLabel(configDir, "toy-smoke").entries[0];

package/dist/test/fixture-loop.test.js

@@ -149,7 +149,7 @@ async function fixtureLoop(t) {
     git(repo, ["init", "-b", "main"]);
     git(repo, ["add", "-A"]);
     // identity pinned via -c BEFORE the subcommand (toy init.mjs convention)
-    git(repo, ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "commit", "-m", "fixloop seed"]);
+    git(repo, ["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "commit", "-m", "fixloop seed"]);
     registerGenome(configDir, specPath);
     const entry = requireGenomesByLabel(configDir, "fixloop-germ").entries[0];
     if (entry === undefined)

package/dist/test/fixtures-self.js

@@ -42,7 +42,7 @@ test("self-sanity: stub mutators deterministic", () => {
 });
 `;
 function git(cwd, ...args) {
-    return execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "-C", cwd, ...args], {
+    return execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "-C", cwd, ...args], {
         encoding: "utf8",
         env: { ...process.env, LC_ALL: "C" },
     }).trim();

package/dist/test/fixtures-wt.js

@@ -13,7 +13,7 @@ export const GIT_ID = [
     "-c",
     "user.name=abathur-test",
     "-c",
-    "user.email=test@abathur.local",
+    "user.email=ci@host.example",
     "-c",
     "commit.gpgsign=false",
 ];

package/dist/test/friction.test.js

@@ -250,7 +250,7 @@ test("AC-2: canary planted in the val unit NEVER appears in the friction queue",
     assert.deepEqual(val, { count: 1, aliases: ["val-1"], samples: 4 }, "scrubbed val material is present as counts/aliases");
 });
 function gitIn(repo, ...args) {
-    execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "-C", repo, ...args], { stdio: "pipe" });
+    execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "-C", repo, ...args], { stdio: "pipe" });
 }
 test("friction: run CLI on drifted kernel records cause cli-error (spawned exit 1)", (t) => {
     const root = mkdtempSync(path.join(os.tmpdir(), "abathur-drift-"));
@@ -264,8 +264,8 @@ test("friction: run CLI on drifted kernel records cause cli-error (spawned exit
     touchSeal(repo, ["units/add.mjs", "units/mul.mjs", "units/explode.mjs", "units/sub.mjs", "grader.mjs"]);
     writeFileSync(path.join(repo, "genome.jsonc"), toySpec(repo), "utf8");
     execFileSync("git", ["init", "-b", "main", repo], { stdio: "pipe" });
-    execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "-C", repo, "add", "-A"], { stdio: "pipe" });
-    execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "-C", repo, "commit", "-m", "genome"], { stdio: "pipe" });
+    execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "-C", repo, "add", "-A"], { stdio: "pipe" });
+    execFileSync("git", ["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "-C", repo, "commit", "-m", "genome"], { stdio: "pipe" });
     registerGenome(configDir, path.join(repo, "genome.jsonc"));
     // drift the sealed grader AFTER registration:
     writeFileSync(path.join(repo, "grader.mjs"), "// tampered\n", "utf8");

package/dist/test/graft.test.js

@@ -96,7 +96,7 @@ async function makeInstance(s, name, opts = {}) {
             ...(opts.requires === undefined ? {} : { requires: opts.requires }),
         };
         writeFileSync(path.join(repo, "genome.jsonc"), `${JSON.stringify(edited, null, 2)}\n`, "utf8");
-        gitC(repo, "-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "commit", "-am", "graft fixture: spec edit");
+        gitC(repo, "-c", "user.name=abathur", "-c", "user.email=agent@host.example", "commit", "-am", "graft fixture: spec edit");
     }
     registerGenome(configDir, path.join(repo, "genome.jsonc"));
     const entry = requireGenomesByLabel(configDir, "toy-smoke").entries[0];