@tachikomagundam/abathur 0.2.4 → 0.2.5

package/config/genomes/historian.example.jsonc

@@ -56,7 +56,7 @@
     "resetCommand": "bash ${ABATHUR_REPO}/graders/historian/reset-sandbox.sh",
     "runCommand": "bash ${ABATHUR_REPO}/graders/historian/run-scenario.sh {unit.id} {repoRoot}/{unit.path}",
     "graderCommand": "node ${ABATHUR_REPO}/graders/historian/grader.mjs {unit.id} {repoRoot}/{unit.path} ${ABATHUR_WIKI_BASE}",
-    "agentModel": "<provider>/<model-id>", // "<provider>/<model-id> as registered in your opencode config"
+    "agentModel": "replace-me/provider/model", // operator: substitute the real <provider>/<model> when copying
     // Real agent runs, not unit tests: 1200s caps one stuck scenario without
     // poisoning the generation (timeout => unscored/inconclusive, excluded by
     // the stats layer). seed+reset hooks share a FIXED 60s adapter budget

package/dist/core/evolve/run-bench.js

@@ -16,10 +16,11 @@ export function cloneMatrixRow(u) {
 export function copyProvenance(p) {
     return { benchType: p.benchType, versions: p.versions.map((v) => ({ bin: v.bin, version: v.version })) };
 }
-// Unscored units (run timeout/infra_failed, inconclusive grader, budget cut) must be
-// excluded before stats.evaluate — empty replicate lists poison aggregateScore with NaN.
+// Invariant: unscored units (timeout/infra_failed/budget cut) stay in the matrix —
+// dropping them asymmetrically shifts one arm's aggregate pool (campaign-6 artifact);
+// evaluate() fail-closes any arm's n<2 as indeterminate before any aggregation.
 export function asReplicates(rows) {
-    return rows.filter((u) => u.scores.length > 0).map((u) => ({ unitId: u.unitId, split: u.split, scores: u.scores }));
+    return rows.map((u) => ({ unitId: u.unitId, split: u.split, scores: u.scores }));
 }
 export * from "./run-rows.js";
 /** toy ⇒ stateless adapter; fixture ⇒ ctor acquires the fingerprint lock immediately. */

package/dist/core/evolve/run-loop.js

@@ -32,7 +32,7 @@ import { compactUtc, fingerprint, genId } from "../ids.js";
 import { LEDGER_KIND_GENERATION_COMPLETE, acquireGenomeLock, Ledger } from "../ledger.js";
 import { openGenome } from "../worktree.js";
 import { clampReps, evaluate, needsExit } from "../stats.js";
-import { effectiveRepoPath, isEnvRepoLiteral } from "../spec.js";
+import { effectiveRepoPath, envRepoName, isEnvRepoLiteral } from "../spec.js";
 import { ChildTracker, reapOrphans } from "./child-track.js";
 import { buildBrief } from "./brief.js";
 import { startRunFriction } from "./run-friction.js";
@@ -101,7 +101,13 @@ async function evolve(opts, mutatorCommand, ledger, caps, reps, env, now) {
     const spec = opts.entry.spec;
     const lines = [];
     const genomeRepo = effectiveRepoPath(spec.repoPath);
-    const selfMode = isEnvRepoLiteral(spec.repoPath);
+    // Engine-self ONLY: a `${VAR}` literal is a path-injection convenience any
+    // harness repo may use (campaign-1 misroute pin: selfmode-literal.test.ts).
+    const selfMode = envRepoName(spec.repoPath) === "ABATHUR_SELF_REPO";
+    // Env-literals resolve to concrete paths exactly once, here at the FS
+    // boundary; bench/reflect drivers below never see the raw literal.
+    // Concrete repoPaths flow through byte-identical to before.
+    const loopSpec = isEnvRepoLiteral(spec.repoPath) ? { ...spec, repoPath: genomeRepo } : spec;
     const fric = opts.friction === undefined ? null : startRunFriction(opts.friction);
     // Reap only under the genome lock: every remaining log entry belongs to a dead run.
     const reap = reapOrphans(genomeRepo);
@@ -131,7 +137,7 @@ async function evolve(opts, mutatorCommand, ledger, caps, reps, env, now) {
     else {
         const gen = genId(fingerprint({ incumbent: opened.headCommit, at: now().getTime() }), now());
         const out = await benchTarget({
-            spec,
+            spec: loopSpec,
             genId: gen,
             reps,
             caps,
@@ -181,7 +187,7 @@ async function evolve(opts, mutatorCommand, ledger, caps, reps, env, now) {
         const brief = buildBrief(spec, evidence, counters);
         tracker.phase(`mutator-${invId}`, "mutator-session");
         const session = await runMutatorSession({
-            spec: selfMode ? { ...spec, repoPath: genomeRepo } : spec,
+            spec: loopSpec,
             brief,
             mutatorCommand,
             ...(opts.opencodeBin === undefined ? {} : { opencodeBin: opts.opencodeBin }),

package/dist/core/evolve/run-plan.js

@@ -1,7 +1,7 @@
 // --dry-run plan rendering + budget-cap resolution (todo 9). Presentation of
 // the resolved startup state only — the dry-run gate in run-loop.ts calls this
 // AFTER the kernel audit and BEFORE any ledger/lock/spawn touch.
-import path from "node:path";
+import { effectiveRepoPath } from "../spec.js";
 import { peekPlanState } from "./run-rows.js";
 /** `--max-candidates` clamps DOWN to the genome's own cap, never above. */
 export function effectiveCaps(spec, clamp) {
@@ -15,12 +15,16 @@ export function effectiveCaps(spec, clamp) {
 }
 export function planLines(req) {
     const spec = req.entry.spec;
-    const peek = peekPlanState(spec.repoPath);
+    // `${VAR}` literals resolve through the same FS-boundary contract as every
+    // other consumer; the plan line + resume peek must never join the raw
+    // literal against cwd.
+    const genomeRepo = effectiveRepoPath(spec.repoPath);
+    const peek = peekPlanState(genomeRepo);
     const specMax = spec.budget.maxCandidates;
     const unitList = spec.bench.units.map((u) => `${u.id}(${u.split})`).join(" ");
     return [
         `run plan — genome '${spec.label}' (${req.entry.fingerprint})`,
-        `  repo: ${path.resolve(spec.repoPath)}`,
+        `  repo: ${genomeRepo}`,
         `  bench: ${spec.bench.type} — timeoutS=${String(spec.bench.timeoutS)} stats minEffect=${String(spec.bench.stats.minEffect)} halfWidth=${String(spec.bench.stats.halfWidth)}`,
         `  units: ${unitList}`,
         ...(req.requiresProbed === undefined

package/dist/core/spec.js

@@ -126,7 +126,11 @@ export function errorText(cause) {
  * resolved ONLY at FS boundaries, never inside the spec.
  */
 const ENV_REPO_LITERAL = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
-/** True when the spec stores an unresolved `${VAR}` env literal (self-genome marker). */
+/**
+ * True when the spec stores an unresolved `${VAR}` env literal — a path-
+ * injection convenience ANY genome may use, NOT an engine-self discriminator
+ * (for that compare envRepoName against ABATHUR_SELF_REPO).
+ */
 export function isEnvRepoLiteral(repoPath) {
     return ENV_REPO_LITERAL.test(repoPath);
 }

package/dist/core/stats.js

@@ -132,29 +132,47 @@ export function evaluate(input) {
     const candByUnit = new Map(candidate.units.map((u) => [u.unitId, u]));
     const incByUnit = new Map(incumbent.units.map((u) => [u.unitId, u]));
     const failures = [];
-    // 2) HARD RULE nReps ≥ 2: n<2 on ANY candidate unit (or a val unit missing
-    //    from the candidate ⇒ n=0) leaves the variance undefined.
-    for (const unit of candidate.units) {
-        if (unit.scores.length < 2) {
-            failures.push(`n=${unit.scores.length} on unit '${unit.unitId}': variance undefined — indeterminate, never nominated`);
+    // 2) Cross-arm replicate rule. A unit measured cleanly (n>=2) on ONE arm but
+    //    not on the other leaves that comparison's variance undefined ⇒
+    //    indeterminate, never a silent cull and never a nomination (campaign-6:
+    //    the candidate's train unit scored while the incumbent's had timed out;
+    //    the old one-sided drop shifted the incumbent aggregate to the val
+    //    fallback and minted a bogus negative gain). A unit unmeasured on BOTH
+    //    arms is excluded symmetrically — every aggregate and comparison then
+    //    runs on a pool both arms share replicate-for-replicate.
+    const excluded = new Set();
+    for (const unitId of new Set([...incByUnit.keys(), ...candByUnit.keys()])) {
+        const cn = candByUnit.get(unitId)?.scores.length ?? 0;
+        const inn = incByUnit.get(unitId)?.scores.length ?? 0;
+        if (cn >= 2 && inn < 2) {
+            failures.push(`n=${inn} on incumbent unit '${unitId}': baseline variance undefined — indeterminate, never nominated`);
         }
-    }
-    for (const [unitId, incUnit] of incByUnit) {
-        if (incUnit.split === "val" && !candByUnit.has(unitId)) {
-            failures.push(`no replicates for val unit '${unitId}' on candidate '${candidate.runId}' — variance undefined, never nominated`);
+        else if (inn >= 2 && cn < 2) {
+            if (incByUnit.get(unitId)?.split === "val") {
+                failures.push(`no replicates for val unit '${unitId}' on candidate '${candidate.runId}' — variance undefined, never nominated`);
+            }
+            else {
+                failures.push(`n=${cn} on unit '${unitId}': variance undefined — indeterminate, never nominated`);
+            }
+        }
+        else if (cn < 2 && inn < 2) {
+            excluded.add(unitId);
         }
     }
     if (failures.length > 0) {
-        return { ...base, verdict: "indeterminate", exitCode: needsExit("indeterminate"), gain: aggregateScore(candidate.units) - aggregateScore(incumbent.units), unitComparisons: [], failures };
+        return { ...base, verdict: "indeterminate", exitCode: needsExit("indeterminate"), gain: null, unitComparisons: [], failures };
     }
+    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.
     const unitComparisons = [];
     for (const [unitId, incUnit] of incByUnit) {
-        if (incUnit.split !== "val")
+        if (incUnit.split !== "val" || excluded.has(unitId))
             continue;
-        const candUnit = candByUnit.get(unitId);
+        const candUnit = candByUnitKept.get(unitId);
         if (candUnit === undefined)
-            continue; // already ruled indeterminate above
+            continue; // excluded/unreachable
         const cs = summarizeUnit(candUnit.scores, alpha);
         const incumbentMean = summarizeUnit(incUnit.scores).mean;
         const delta = cs.mean - incumbentMean;
@@ -174,8 +192,8 @@ export function evaluate(input) {
             failures.push(`regression on unit '${unitId}': delta ${fmt(delta)} < ${fmt(-cs.ciHalfWidth)} (mean ${fmt(cs.mean)} < ${fmt(incumbentMean)} - ${fmt(cs.ciHalfWidth)})`);
         }
     }
-    // 4) Effect-size floor on the aggregate gain.
-    const gain = aggregateScore(candidate.units) - aggregateScore(incumbent.units);
+    // 4) Effect-size floor on the aggregate gain (shared, symmetric pool).
+    const gain = aggregateScore(candKept) - aggregateScore(incKept);
     if (gain < stats.minEffect) {
         failures.push(`gain ${fmt(gain)} < minEffect ${fmt(stats.minEffect)}`);
     }