slice-tournament-zoo 0.7.2 → 0.9.5

package/README.md

@@ -261,6 +261,36 @@ You, the session, become the orchestrator. The command:
 
 Every exact decision is made by the CLI, never by the agent's own arithmetic.
 
+### Evolve the harness itself (0.9.0, opt-in)
+
+STZ can improve **its own harness**, not just the code it produces. The per-slice
+tournament stays exactly as above; a separate, default-off meta-loop evolves the
+harness *genome* (test-author heuristics, specimen strategies, judge rubric,
+selection weights, fan-out, the suite battery) against **held-out, recall-free**
+pilot fitness — a DGM/HarnessX-style archive selected by GRPO advantage with a
+six-gate promotion guard (0.9.5 adds calibrated-verifier gating: a selection
+judge must pass a blind target-task accuracy battery before it may steer a
+promotion, fail-closed).
+
+```text
+/stz:inject slice-01     # adversarially harden the sealed suite (find blind spots)
+/stz:evolve              # run the bounded harness-evolution meta-loop (needs harness.enabled)
+```
+
+The flagship is **automated suite sharpening**: a blind-spot bug-class the judge
+finds past a green suite (e.g. the `5abc` malformed-token trap) is mined *once*
+into the test-author's repertoire + the mutation battery, so every future suite is
+born sharper at ~0 marginal cost — instead of re-deriving it per slice. This is
+the empirically-grounded relocation of the shelved 0.8.0 per-slice convergence
+loop (ruled out budget-matched and recall-free; see `docs/ROADMAP.md` and
+`experiments/swebench-pilot/PILOT-RESULTS-{BLIND,JUDGE}.md`). Bridge primitives:
+`inject`, `harness-mine`, `harness-promote-mutator`, `harness-spawn`,
+`harness-fitness`, `harness-select`, `harness-promote`, `harness-status`,
+`judge-stress`, `judge-calibration`. A 0.9.5 authoring gene
+(`waf-playbook-autogen-v0`) lets the test author bake AWS Well-Architected
+playbook edge-cases for contracted behaviour (one-time, never a reward). Every
+kill-switch halts and surfaces; nothing auto-rewrites its own guard.
+
 ## Example commands and workflows
 
 ### A whole project (the full pipeline)
@@ -405,3 +435,10 @@ For contributors and anyone going past day-to-day operation:
 ## License
 
 [Apache-2.0](https://github.com/dr-robert-li/slice-tournament-zoo/blob/main/LICENSE).
+
+## Research
+
+The full account of what STZ is, the experiments under `experiments/`, the outcomes, and
+the open questions is in **[docs/PAPER.md](docs/PAPER.md)** ("When does a self-improving
+coding harness actually improve competency? A negative result, earned"). The first-person
+build log is in [docs/JOURNAL.md](docs/JOURNAL.md).

package/agents/stz-harness-critic.md

@@ -0,0 +1,42 @@
+---
+name: stz-harness-critic
+description: HarnessX-style Critic for the STZ harness-evolution meta-loop (0.9.0). Validates a candidate harness variant on the HELD-OUT pilot fitness before promotion. Reads the truth suites; blind to which variant authored which output (no genome-authorship bias).
+tools: Read, Bash, Grep, Glob
+model: inherit
+---
+
+You are the **Critic** in the STZ harness-evolution meta-loop (the C in HarnessX's
+Digester→Planner→Evolver→Critic). The Evolver proposed a harness **variant** (one
+gene changed: a test-author heuristic, a specimen strategy, a judge rubric, a
+selection-weight tuple, fan-out, or a battery mutator). Your job is to decide
+whether it genuinely improves the harness — on **held-out, recall-free** fitness,
+not on the training traces.
+
+## Inputs
+- The variant's **per-substrate truth scores** on the recall-free pilots
+  (`experiments/{cron,hexcolor,ipv4}-pilot/truth-suite/`), already computed by
+  running the variant's tournament on each pilot.
+- The current **incumbent** archive entry (`bridge harness-status`).
+
+## What you check (and how to stay honest)
+1. **Beats the incumbent at equal-or-lower budget.** A variant that wins only by
+   spending more tokens is rejected (the JUDGE pilot's "B overspent and only tied"
+   is the cautionary baseline). Use the budget-matched comparison.
+2. **No regression on any substrate** the incumbent already passed. A variant that
+   trades a cron win for a hexcolor loss is not an improvement.
+3. **Convention axes discounted.** Spec-silent / recall axes (`7`=Sunday,
+   leading-zero, whitespace) are reported separately, never folded into the
+   primary fitness — they are the contamination the synthetic substrate exists to
+   exclude.
+4. **Symmetric error.** "No variant beats the incumbent → keep the incumbent" is a
+   SUCCESS outcome, not a failure. Do not manufacture a winner.
+
+## What you must NOT do
+- Do NOT read which genome authored which output before scoring (authorship bias).
+- Do NOT auto-rewrite anything. You emit a verdict; the bridge `harness-promote`
+  six-gate runs the actual promotion (and it also checks hack-clean on the
+  variant's own outputs, seal integrity, interface parity, and — 0.9.5 — that the
+  selection judge is target-task calibrated, else it fails closed).
+
+Return: a per-substrate comparison table, the budget note, and a PROMOTE /
+HOLD verdict with the deciding reason. The decision is earned, not asserted.

package/agents/stz-injector.md

@@ -0,0 +1,41 @@
+---
+name: stz-injector
+description: Adversarial bug-injector for STZ suite hardening (0.9.0, SSR-style). Perturbs a WINNING specimen into plausible variants it believes still satisfy the contract, to surface blind spots the sealed suite cannot see. Blind to the truth oracle and the sealed suite source.
+tools: Read, Write, Bash, Grep, Glob
+model: inherit
+---
+
+You are the **bug-injector** in an STZ suite-hardening round. Your adversary is the
+**sealed test suite**, not the contract. Your job: make the suite's blind spots
+visible so the test-author can close them.
+
+## What you may read
+- The slice **contract** (`.stz/40-slices/<id>/manifest.json` + `plan.md`).
+- ONE **winning specimen's source** (the tournament winner's `index.*`).
+
+## What you must NOT read (the blindness contract)
+- The sealed suite source (`.stz/30-tests/held-out/`), its reference, or any
+  truth/oracle file. You are blind to the grader. (A silent read defeats the
+  whole experiment — every finding in `experiments/*/FINDINGS.md` is recall-free
+  precisely because this held.)
+
+## What you produce
+Plausible **mutant variants** of the winner that you BELIEVE a reviewer would
+still accept as contract-satisfying, but that perturb behaviour — drop a
+validation branch, loosen a boundary, accept a malformed token. Write each as a
+candidate mutator spec `{name, find, replace}` (a regex substitution over the
+winner's source) so the bridge can apply it deterministically.
+
+The harness runs your candidates through `bridge inject` / `harness-mine`:
+- a mutant the sealed suite **still passes** is a real blind spot (survives);
+- a mutant the suite **kills** is already covered — discard it.
+
+## The hard rule you must respect
+A surviving mutant is only a real defect if it violates a **named contract
+clause**. You do not decide that — the cross-reference adjudicator does. And you
+must **never** propose keying a test to your mutant's exact bytes; the test-author
+writes a GENERAL property over the violated clause's input class (train-on-test is
+forbidden — see `experiments/swebench-pilot/PILOT-RESULTS-JUDGE.md`).
+
+Return the candidate mutator specs and a one-line rationale per spec naming the
+contract clause you think each violates. Nothing is sealed by you.

package/agents/stz-test-author.md

@@ -92,6 +92,43 @@ do not invent requirements the implementers were never given. That produces the
 mirror failure (failing correct code on an unstated rule), the same class the
 invariant rules above guard against.
 
+## Heuristic gene: `heuristicId` routing (the G1 gene)
+
+The slice's harness genome carries a `heuristicId` (passed to you by the
+orchestrator). It selects which negative-case repertoire you draw on. It only
+changes *which edge cases you reach for* — never the contract you test:
+
+- **`baseline-v0` / `explicit-examples-v0`** — hand-written example cases over the
+  contract clauses (the default).
+- **`property-fuzz-v1`** — prefer property-based generators over the negative
+  space (the approach the section above already recommends).
+- **`waf-playbook-autogen-v0`** — additionally consult the **AWS Well-Architected
+  playbook bank** (the AWS Well-Architected Agentic AI Lens + the
+  `aws-samples/well-architected-skills-and-steering` skills, carried as steering
+  text in `.stz/20-standards/`) to sharpen negative/edge cases for the
+  reliability-, observability-, and guardrail-shaped behaviours **the contract
+  already specifies** — e.g. a contracted retry/back-off clause gets a case
+  asserting it actually retries and eventually gives up; a contracted
+  idempotency/least-privilege/timeout clause gets a discriminating negative.
+
+### The Goodhart guard for `waf-playbook-autogen-v0` (load-bearing — do not relax)
+
+This is **one-time amortized authoring**, not a score to optimise. Two hard rules,
+both required (the survey `experiments/META-RSI-SURVEY.md` §II.3 earned why):
+
+1. **WAF practices only sharpen cases for behaviour the contract already
+   specifies. They never add a WAF requirement the contract is silent on.** A
+   WAF-flavoured test for an unstated requirement is the exact "stay within the
+   contract" violation above, *and* it would smuggle WAF-conformance into the
+   sealed suite — which then *is* the fitness signal, making conformance a reward
+   by the back door. If the contract does not mention the pillar behaviour, do not
+   test it.
+2. **No WAF-conformance score is ever computed as fitness.** The selection
+   `weights` tuple stays `{pass, coverage, kill, codeHealth, clean}`; promotion
+   stays on held-out *functional* fitness only. An LLM-judged "how Well-Architected
+   does this look" score is appearance-adjacent and must never enter selection
+   (that is the conformance-judge failure mode the survey rules out).
+
 ## Reference implementation (proves the suite is satisfiable)
 
 Also write a **minimal, correct reference implementation** of the contract into

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "slice-tournament-zoo",
-  "version": "0.7.2",
-  "description": "STZ: a contract-bounded slice pipeline that implements each slice adversarially via an N-specimen tournament with frozen sealed tests, GRPO-style selection, layered anti-reward-hacking, and a replayable markdown audit trail.",
+  "version": "0.9.5",
+  "description": "STZ: a contract-bounded slice pipeline that implements each slice adversarially via an N-specimen tournament with frozen sealed tests, GRPO-style selection, layered anti-reward-hacking, a replayable markdown audit trail, and (0.9.0) a bounded harness-level recursive-self-improvement meta-loop that evolves the harness against held-out pilot fitness.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/dr-robert-li/slice-tournament-zoo#readme",
   "repository": {

package/src/bridge.ts

@@ -56,14 +56,34 @@ import {
   runConfigExists,
   defaultRunConfig,
 } from "./project.js";
-import { detectHacks } from "./hack-detector.js";
+import { detectHacks, suspicionScore } from "./hack-detector.js";
 import { STZ_VERSION, SCHEMA_VERSION, PACKAGE_NAME } from "./version.js";
 import { onNoPassers, type EscalationState } from "./escalation.js";
 import { evalGate, select, pairings } from "./selection.js";
 import { diffSpecs, renderSpecDiff, isFaithful, unmatchedIntentIds, mismatchedAsBuiltIds, type Spec } from "./specdiff.js";
 import { seal, verifySeal, amendSeal, heldOutFiles } from "./seal.js";
 import { renderPressureLog, refinementContext, type CulledSpecimen } from "./pressure.js";
-import { fullEval, crossReference } from "./eval-runner.js";
+import { fullEval, crossReference, injectMutants, loadBattery, type MutatorSpec } from "./eval-runner.js";
+import { groupRelativeAdvantage } from "./grpo.js";
+import { checkDiversity, frontierWeights, weightedFitness } from "./diversity.js";
+import { checkParity } from "./harness-hash.js";
+import {
+  readArchive,
+  appendArchiveEntry,
+  bumpChildCount,
+  incumbent,
+  sampleParents,
+  makeArchiveEntry,
+  promotionGate,
+  batteryDir,
+  readReliabilityProfile,
+  mergeReliabilityEntry,
+  defaultGenome,
+  type MetaState,
+} from "./harness.js";
+import { initialInject, onInjectRound, summarizeSurvivors } from "./injector.js";
+import { consistencyScore, bucketOf, calibrationGate } from "./judge-reliability.js";
+import type { ArchiveEntry, HarnessGenome } from "./types.js";
 import {
   loadCompat,
   saveCompat,
@@ -193,12 +213,15 @@ function commitEval(
   root: string,
   slice: string,
   specimen: string,
-  metrics: { testPassRate: number; coverage: number; mutationScore: number },
+  metrics: { testPassRate: number; coverage: number; mutationScore: number; codeHealth?: number },
   fixtureNames: string[],
   extra: Record<string, unknown> = {},
 ): void {
   const files = readSpecimenFiles(root, slice, specimen);
   const hackFindings = detectHacks(specimen, files, { fixtureNames });
+  // 0.9.0: graded soft-suspicion (a hard-passer can still carry it) + code-health
+  // feed the multi-objective reward. codeHealth absent ⇒ neutral best (1).
+  const suspicion = suspicionScore(files, { fixtureNames });
   const result: EvalResult = {
     specimen,
     passedGate: metrics.testPassRate >= 1 && hackFindings.length === 0,
@@ -206,6 +229,8 @@ function commitEval(
     coverage: metrics.coverage,
     mutationScore: metrics.mutationScore,
     hackFindings,
+    ...(metrics.codeHealth !== undefined ? { codeHealth: metrics.codeHealth } : {}),
+    suspicion,
   };
   const out = evalResultPath(root, slice, specimen);
   mkdirSync(join(out, ".."), { recursive: true });
@@ -227,14 +252,16 @@ function recordEval(args: Record<string, string>): void {
  */
 function evalCmd(args: Record<string, string>): void {
   const { root, slice, specimen } = args as { root: string; slice: string; specimen: string };
-  const e = fullEval(args.sealed!, args.impl!);
+  // Promoted bug-class mutators under 60-harness/battery participate in mutation
+  // scoring when present (the sharpened battery), so a hardened suite is rewarded.
+  const e = fullEval(args.sealed!, args.impl!, existsSync(batteryDir(root)) ? batteryDir(root) : undefined);
   commitEval(
     root,
     slice,
     specimen,
-    { testPassRate: e.testPassRate, coverage: e.coverage, mutationScore: e.mutationScore },
+    { testPassRate: e.testPassRate, coverage: e.coverage, mutationScore: e.mutationScore, codeHealth: e.codeHealth },
     args.fixtures ? args.fixtures.split(",") : [],
-    { measured: { passed: e.passed, total: e.total, mutants: e.mutants, survivors: e.survivors } },
+    { measured: { passed: e.passed, total: e.total, mutants: e.mutants, survivors: e.survivors, codeHealth: e.codeHealth } },
   );
 }
 
@@ -1039,6 +1066,327 @@ async function mergeValidate(args: Record<string, string>): Promise<void> {
   print(verdict);
 }
 
+// ════════════════════════════════════════════════════════════════════════════
+// 0.9.0 — Harness-level recursive self-improvement (meta-loop) bridge commands.
+// The bridge owns ALL compute (N6): agents feed numbers in, never do arithmetic.
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Read JSON from a file path OR an inline JSON string arg. */
+function readJSONArg<T>(v: string | undefined): T | null {
+  if (!v || v === "true") return null;
+  if (existsSync(v)) return readJSON<T>(v);
+  try {
+    return JSON.parse(v) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * inject: adversarial suite hardening (SSR-style). Run the mutation battery
+ * (built-ins ∪ promoted) against a winning impl; mutants the SEALED suite still
+ * passes are candidate blind spots. Reports survivors + the bounded-FSM next
+ * action. Promotion of a survivor into a sealed test is a SEPARATE, gated step
+ * (adjudicate clause → general PBT case → seal-amend → reference re-verify) —
+ * this command only DISCOVERS, it never amends.
+ */
+function injectCmd(args: Record<string, string>): void {
+  const sealed = args.sealed;
+  const impl = args.impl;
+  if (!sealed || !impl) {
+    process.stderr.write("inject requires --sealed <suite> and --impl <winning-specimen>.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const battery = loadBattery(args.root ? batteryDir(args.root) : args.battery);
+  const survivors = injectMutants(sealed, impl, battery);
+  const { action } = onInjectRound(initialInject(), { survivors: survivors.length, promoted: 0 });
+  print({
+    batterySize: battery.length,
+    survivors: summarizeSurvivors(survivors),
+    blindSpotFound: survivors.length > 0,
+    nextAction: action,
+    note:
+      survivors.length > 0
+        ? "Blind spot(s) found. Adjudicate each against a NAMED contract clause; only a clause-violating survivor becomes a GENERAL (not mutant-keyed) sealed test via seal-amend + reference re-verify."
+        : "No survivor — the sealed suite caught every injected variant.",
+  });
+}
+
+/**
+ * harness-mine: the test-author skill-mining verifier (promotion gate half i).
+ * Given a candidate bug-class mutator spec, does it SURVIVE the given sealed
+ * suite (a genuine, currently-uncaught blind spot)? A mutator the incumbent
+ * suite already kills is a no-op and rejected. The complementary half (ii) — the
+ * sharpened suite KILLS it — is a second call against the amended suite expecting
+ * `survives:false`.
+ */
+function harnessMine(args: Record<string, string>): void {
+  const sealed = args.sealed;
+  const impl = args.impl;
+  // Accept either a single MutatorSpec or a battery-style array (take the first).
+  const raw = readJSONArg<MutatorSpec | MutatorSpec[]>(args.mutator ?? args["mutator-spec"]);
+  const spec = Array.isArray(raw) ? raw[0] : raw;
+  if (!sealed || !impl || !spec?.name || !spec.find) {
+    process.stderr.write("harness-mine requires --sealed, --impl, and --mutator <spec.json|inline> ({name,find,replace}).\n");
+    process.exitCode = 1;
+    return;
+  }
+  const survivors = injectMutants(sealed, impl, [
+    { name: spec.name, apply: (s) => (new RegExp(spec.find, spec.flags ?? "")).test(s) ? s.replace(new RegExp(spec.find, spec.flags ?? ""), spec.replace) : null },
+  ]);
+  const survives = survivors.length > 0;
+  print({
+    mutator: spec.name,
+    survives,
+    verdict: survives
+      ? "SURVIVES — a genuine, currently-uncaught blind spot (promotion gate half i ✓). Author the general heuristic, then re-run against the sharpened suite expecting survives:false."
+      : "killed — the suite already catches this class; not a blind spot. Rejected as a no-op.",
+  });
+}
+
+/** harness-promote-mutator: append a TWICE-verified mutator spec to the battery. */
+async function harnessPromoteMutator(args: Record<string, string>): Promise<void> {
+  const root = args.root;
+  const rawSpec = readJSONArg<MutatorSpec | MutatorSpec[]>(args.spec);
+  const spec = Array.isArray(rawSpec) ? rawSpec[0] : rawSpec;
+  if (!root || !spec?.name) {
+    process.stderr.write("harness-promote-mutator requires --root and --spec <mutator.json> with a name.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const dir = batteryDir(root);
+  mkdirSync(dir, { recursive: true });
+  const file = join(dir, `${spec.name.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  await writeFile(file, JSON.stringify([spec], null, 2) + "\n", "utf8");
+  print({ promoted: spec.name, battery: file, batterySize: loadBattery(dir).length });
+}
+
+/**
+ * harness-spawn: deterministically sample K parents from the archive (DGM rule
+ * P ∝ fitness/(1+childCount)) and emit their genomes as mutation seeds. An empty
+ * archive yields the default/incumbent genome as the sole seed.
+ */
+function harnessSpawn(args: Record<string, string>): void {
+  const root = args.root!;
+  const k = Math.max(1, Math.round(Number(args.k ?? "4")));
+  const archive = readArchive(root);
+  const parents = archive.length === 0
+    ? [{ variantId: "seed", genome: defaultGenome() }]
+    : sampleParents(archive, k).map((p) => ({ variantId: p.variantId, genome: p.genome }));
+  print({ count: parents.length, parents, note: "Mutate ONE gene per child (HarnessX substitution); realize via the agent layer, then score with harness-fitness." });
+}
+
+/**
+ * harness-fitness: compute a variant's held-out fitness from per-substrate truth
+ * scores (the agent layer ran the variant's tournament on each recall-free pilot
+ * and passes the numbers in), AceGRPO-weighted toward the learnable frontier
+ * (substrates where the incumbent is mid-band), then append a content-addressed
+ * ArchiveEntry. The bridge owns the math; agents never compute it.
+ */
+async function harnessFitness(args: Record<string, string>): Promise<void> {
+  const root = args.root!;
+  const genome = readJSONArg<HarnessGenome>(args.genome);
+  const scores = readJSONArg<Record<string, number>>(args.scores);
+  if (!genome || !scores) {
+    process.stderr.write("harness-fitness requires --root, --genome <genome.json>, --scores <{substrate:score}>.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const substrates = Object.keys(scores).sort();
+  const inc = incumbent(root);
+  const incPer = substrates.map((s) => inc?.perSubstrate[s] ?? 0.5);
+  const weights = frontierWeights(incPer);
+  const fitness = weightedFitness(substrates.map((s) => scores[s]!), weights);
+  const entry = makeArchiveEntry({
+    genome,
+    parent: args.parent && args.parent !== "true" ? args.parent : inc?.variantId ?? null,
+    fitness,
+    perSubstrate: scores,
+    advantage: 0, // filled by harness-select within its generation
+    gates: { hackClean: false, sealOk: false, interfaceParity: false, diversityOk: false, beatsIncumbent: false, rubricCalibrated: false },
+  });
+  appendArchiveEntry(root, entry);
+  if (entry.parent) bumpChildCount(root, entry.parent);
+  print({ variantId: entry.variantId, fitness, weights, perSubstrate: scores, incumbentFitness: inc?.fitness ?? null });
+}
+
+/**
+ * harness-select: GRPO group-relative advantage over a generation of variants
+ * (the harness altitude), with the variance-collapse guard. Returns the
+ * max-advantage winner and whether the generation carried enough spread to rank.
+ */
+function harnessSelect(args: Record<string, string>): void {
+  const variants = readJSONArg<{ variantId: string; fitness: number }[]>(args.variants);
+  if (!variants || variants.length === 0) {
+    process.stderr.write("harness-select requires --variants <[{variantId,fitness}]>.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const floor = Number(args.floor ?? "0.02");
+  const diversity = checkDiversity(variants.map((v) => v.fitness), floor);
+  const advantages = groupRelativeAdvantage(variants.map((v) => ({ specimen: v.variantId, reward: v.fitness })));
+  const ranked = [...advantages].sort((a, b) => b.advantage - a.advantage);
+  print({
+    diversity,
+    winner: diversity.ok ? ranked[0]?.specimen ?? null : null,
+    advantages: ranked,
+    note: diversity.ok
+      ? "Generation has spread; winner is the max-advantage variant."
+      : "VARIANCE COLLAPSE — σ below floor. Do NOT promote; re-sample with forced gene diversity (RC-GRPO).",
+  });
+}
+
+/**
+ * harness-promote: the five-gate promotion decision (DGM hack-resistance). A
+ * variant becomes incumbent only if it beats the incumbent on held-out fitness
+ * AND is hack-clean on its OWN outputs AND preserved sealing integrity AND
+ * interface parity AND came from a diverse generation.
+ */
+function harnessPromote(args: Record<string, string>): void {
+  const root = args.root!;
+  const variantId = args.variant;
+  const archive = readArchive(root);
+  const variant = archive.find((e) => e.variantId === variantId);
+  if (!variant) {
+    process.stderr.write(`harness-promote: variant ${variantId} not in archive.\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const bool = (k: string): boolean => args[k] === "true" || args[k] === undefined ? args[k] === "true" : String(args[k]).toLowerCase() === "true";
+  // "Beats incumbent" must compare against the prior incumbent, NOT this variant
+  // itself (it may already be the max-fitness archived entry). Prefer an explicit
+  // baseline fitness from the caller; else the best fitness among OTHER entries.
+  const others = archive.filter((e) => e.variantId !== variantId);
+  const baseline =
+    args["baseline-fitness"] !== undefined && args["baseline-fitness"] !== "true"
+      ? Number(args["baseline-fitness"])
+      : others.length
+        ? Math.max(...others.map((e) => e.fitness))
+        : -Infinity;
+  const beatsIncumbent = variant.fitness > baseline;
+  // Interface parity: the variant must not change the bridge command surface.
+  const incumbentCommands = BRIDGE_COMMANDS;
+  const variantCommands = readJSONArg<string[]>(args["variant-commands"]) ?? BRIDGE_COMMANDS;
+  const parity = checkParity(incumbentCommands, variantCommands);
+  // Calibrated-verifier gate (0.9.5, fail-closed): the judge that produced this
+  // variant's selection signal must be target-task calibrated before it may steer
+  // promotion (2606.14629 — an uncalibrated verifier silently regresses). A
+  // missing --slice-type, or a slice-type whose blind-accuracy battery has not
+  // run, reads as uncalibrated.
+  const sliceType = args["slice-type"];
+  const profile = readReliabilityProfile(root);
+  const calib = sliceType
+    ? calibrationGate(profile, sliceType)
+    : { calibrated: false, reason: "no --slice-type — judge calibration unknown (fail-closed)" };
+  const inputs = {
+    beatsIncumbent,
+    hackClean: bool("hack-clean"),
+    sealOk: bool("seal-ok"),
+    interfaceParity: parity.ok,
+    diversityOk: bool("diversity-ok"),
+    rubricCalibrated: calib.calibrated,
+  };
+  const verdict = promotionGate(inputs);
+  // Record the gate snapshot on the entry (audit), append-rewrite is fine: the
+  // archive is the durable record and this is the gate result for THIS variant.
+  variant.gates = { ...inputs };
+  writeFileSync(join(stzPath(root, "60-harness"), "MANIFEST.json"), JSON.stringify(archive, null, 2) + "\n", "utf8");
+  print({ variantId, inputs, ...verdict, parity, calibration: calib, baselineFitness: baseline === -Infinity ? null : baseline, variantFitness: variant.fitness });
+}
+
+/** harness-status: archive summary, incumbent, and meta-loop view. */
+function harnessStatus(args: Record<string, string>): void {
+  const root = args.root!;
+  const archive = readArchive(root);
+  const inc = incumbent(root);
+  const meta: Pick<MetaState, "generation"> = { generation: archive.length };
+  print({
+    archiveSize: archive.length,
+    incumbent: inc ? { variantId: inc.variantId, fitness: inc.fitness, perSubstrate: inc.perSubstrate } : null,
+    battery: loadBattery(batteryDir(root)).map((m) => m.name),
+    variants: archive.map((e) => ({ variantId: e.variantId, parent: e.parent, fitness: e.fitness, childCount: e.childCount, promoted: e.gates.beatsIncumbent })),
+    meta,
+  });
+}
+
+/**
+ * judge-stress: consistency CI check (no labels). Given pairwise judgments re-run
+ * under an order/verbosity swap, score the fraction whose winner is invariant —
+ * a reliability signal grounded in the real cron order-effect. Writes a
+ * per-slice-type profile under 90-audit/judge-reliability.md. NEVER aggregates
+ * multiple judges (naive ensembles amplify bias — arXiv:2505.19477).
+ */
+async function judgeStress(args: Record<string, string>): Promise<void> {
+  const pairs = readJSONArg<{ original: string; perturbed: string }[]>(args.pairs);
+  const sliceType = args["slice-type"] ?? "unknown";
+  if (!pairs) {
+    process.stderr.write("judge-stress requires --pairs <[{original,perturbed}]> and optional --slice-type.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const result = consistencyScore(pairs);
+  const bucket = bucketOf(result.score);
+  if (args.root) {
+    // Persist the machine-readable profile the promotion gate consumes. Merge so
+    // a blind-accuracy bucket already written by judge-calibration is preserved
+    // (the two commands own different fields and may run in either order).
+    mergeReliabilityEntry(args.root, { sliceType, consistency: result.score, n: result.total });
+    await writeDoc(args.root, join("90-audit", "judge-reliability.md"), {
+      frontmatter: { summary: `Judge consistency for ${sliceType}: ${(result.score * 100).toFixed(0)}% invariant under perturbation (n=${result.total}, ${bucket}).` },
+      body:
+        `# Judge reliability profile\n\n` +
+        `Single robust judge, stress-tested for consistency (NO naive ensembling — more judges amplify bias).\n\n` +
+        `- **slice-type:** ${sliceType}\n- **consistency (order/verbosity invariance):** ${result.invariant}/${result.total} = ${result.score.toFixed(3)} (${bucket})\n` +
+        `- **blind-battery accuracy:** pending (must be authored blind to judge rationales — a self-built battery is circular)\n\n` +
+        `Below ${0.7} ⇒ down-weight the judge for this slice-type and lean on the sealed/truth divergence backstop.\n`,
+      ...({} as Record<string, never>),
+    });
+  }
+  print({ sliceType, ...result, bucket });
+}
+
+/**
+ * judge-calibration (0.9.5): measure the judge's TARGET-TASK accuracy on a blind,
+ * pre-registered ground-truth battery and persist the bucket. This is the
+ * calibration 2606.14629 requires BEFORE a verifier may steer promotion: a judge
+ * that is above-threshold on one slice-type can be sub-threshold on another, and
+ * a confident-but-wrong verifier regresses worse than a random one. The agent
+ * layer runs the judge on the blind battery and passes its picks (`--verdicts`)
+ * alongside the ground-truth labels (`--labels`); the bridge owns the arithmetic
+ * (no model call — N6). Writes `blindAccuracyBucket` into the same per-slice-type
+ * profile entry judge-stress fills, merge-preserving its consistency field.
+ */
+function judgeCalibration(args: Record<string, string>): void {
+  const root = args.root;
+  const sliceType = args["slice-type"];
+  const verdicts = readJSONArg<string[]>(args.verdicts);
+  const labels = readJSONArg<string[]>(args.labels);
+  if (!root || !sliceType || !verdicts || !labels || verdicts.length !== labels.length || verdicts.length === 0) {
+    process.stderr.write(
+      "judge-calibration requires --root, --slice-type, --verdicts <[picked]>, --labels <[groundTruth]> (equal, non-empty arrays).\n",
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const correct = verdicts.filter((v, i) => v === labels[i]).length;
+  const accuracy = correct / verdicts.length;
+  const bucket = bucketOf(accuracy);
+  mergeReliabilityEntry(root, { sliceType, blindAccuracyBucket: bucket, n: verdicts.length });
+  print({ sliceType, accuracy, bucket, correct, n: verdicts.length });
+}
+
+/** The pinned bridge command surface — the interface a variant must preserve. */
+const BRIDGE_COMMANDS = [
+  "version", "begin", "record-eval", "eval", "gate", "escalate", "record-votes", "select", "finalize",
+  "project-init", "project-phase", "project-write-intent", "project-record-area", "project-set-config",
+  "project-dark-factory", "project-config", "slice-add", "project-seed-slices", "project-status", "summary",
+  "seal", "seal-verify", "seal-crosscheck", "seal-amend", "merge-validate", "merge-compat-propose",
+  "merge-compat-approve", "merge-compat-retire", "merge-compat-list",
+  "inject", "harness-mine", "harness-promote-mutator", "harness-spawn", "harness-fitness", "harness-select",
+  "harness-promote", "harness-status", "judge-stress", "judge-calibration",
+];
+
 export async function runBridge(argv: string[]): Promise<void> {
   const [sub, ...rest] = argv;
   const args = parseArgs(rest);
@@ -1072,6 +1420,17 @@ export async function runBridge(argv: string[]): Promise<void> {
     case "merge-compat-approve": await mergeCompatApprove(args); break;
     case "merge-compat-retire": await mergeCompatRetire(args); break;
     case "merge-compat-list": mergeCompatList(args); break;
+    // ── 0.9.0 harness-level RSI meta-loop ──────────────────────────────────
+    case "inject": injectCmd(args); break;
+    case "harness-mine": harnessMine(args); break;
+    case "harness-promote-mutator": await harnessPromoteMutator(args); break;
+    case "harness-spawn": harnessSpawn(args); break;
+    case "harness-fitness": await harnessFitness(args); break;
+    case "harness-select": harnessSelect(args); break;
+    case "harness-promote": harnessPromote(args); break;
+    case "harness-status": harnessStatus(args); break;
+    case "judge-stress": await judgeStress(args); break;
+    case "judge-calibration": judgeCalibration(args); break;
     default:
       process.stderr.write(`unknown bridge subcommand: ${sub}\n`);
       process.exitCode = 1;