2sagaco48 1.0.0

package/src/lib/innovation-genome-v3.orig.ts

@@ -0,0 +1,2015 @@
+/**
+ * innovation-genome-v3.ts — Innovation Genome Engine V3.0, verified discovery
+ * runtime. TypeScript port of the supplied `innovation_genome_v3.py`.
+ * ============================================================================
+ * RUNTIME HONESTY (per task instructions — read before trusting any claim
+ * of "verbatim 1:1" below):
+ *
+ *   Tools actually available in this session: file read/write/edit, a Vite
+ *   build tool, static grep. No Python interpreter, no independent test
+ *   runner, no network fetch, no theorem prover, no SQLite. Nothing below
+ *   was executed against the original Python file — it could not be, because
+ *   the Python source pasted into the task was itself already truncated
+ *   (see §7 note) before it reached this file. Every claim of "1:1" is a
+ *   claim about the TypeScript SOURCE CODE topology (same class/field names,
+ *   same algorithms, same validation rules), verified by side-by-side reading
+ *   of this file against the pasted spec — not by running both and diffing
+ *   output, which is impossible without a Python runtime in this workspace.
+ *
+ *   Sections 1–6 of the pasted spec (deterministic utilities, the P/A/E/N/V/T/S
+ *   graph-life scheduler, GoalSpec/EvaluatorSpec/Candidate/Report dataclasses,
+ *   adapter protocols, mutation policy + calibration, budget accounting) were
+ *   supplied WITHOUT truncation. Those are ported line-for-line: same field
+ *   names, same validation predicates, same hashing material, same thresholds.
+ *
+ *   Section 7 onward (EventStore SQL bodies, ToolRegistry, the 7-D descriptor,
+ *   the versioned archive, the GEPA-feedback mutation engine, the discovery
+ *   engine, and `generate_v3_report`) arrived in the task prompt with the SQL
+ *   query strings and several class/method BODIES already blanked out by
+ *   whatever stripped the code before it reached me (e.g. `self.@7.@KC(,
+ *   (row,))` — the query text itself is missing, only the call shape survives).
+ *   I cannot invent the exact missing SQL and call it "verbatim" — that would
+ *   be a fabrication. Instead: every CONTRACT that IS fully legible in that
+ *   truncated region (event-hash chain material, `verify_chain` walk logic,
+ *   checkpoint hashing, memory priority validation, the "Versioning Invariant"
+ *   docstring, the 105-mechanism report shape actually printed by
+ *   `generate_v3_report`, and the full CLI `main()` body) is reproduced
+ *   exactly. Where only a docstring survived and the body did not (the
+ *   subprocess tool adapter, the archive bucketing, the mutation engine, the
+ *   discovery engine's internal loop), I implement the DESCRIBED BEHAVIOUR in
+ *   full, functioning, non-mocked code, and say so explicitly in the comment
+ *   directly above each such class. SQLite itself does not exist in a browser
+ *   runtime at all (no filesystem, no native SQLite driver in a Vite SPA), so
+ *   the EventStore below is disclosed, necessary substitution: an in-memory,
+ *   hash-chained event log using the EXACT SAME hashing algorithm the spec
+ *   gives for `append_event`/`verify_chain`, backed by `localStorage` so it
+ *   survives reloads the same way the Python version's on-disk SQLite file
+ *   would survive process restarts.
+ * ============================================================================ */
+
+import {
+  DIMENSIONS,
+  compileInnovationPrompt,
+  seedToGenome,
+  type Genome,
+} from '@/lib/innovation-genome-engine';
+import {
+  DIMENSION_BLOCKS,
+  DOMAIN_PACKS,
+  CapabilityGate,
+  SafetyGate,
+  applyMutation,
+  classifyPersonaExtended,
+  selectPathExtended,
+  type DomainPack,
+  type RiskTier,
+} from '@/lib/innovation-genome-engine-v2';
+
+// ═══════════════════════════════════════════════════════════════════════
+// 0. Synchronous SHA-256 (FIPS 180-4) — browsers have no synchronous
+//    crypto.subtle.digest, and content_hash is used as a *synchronous*
+//    getter throughout the Python spec (a @property), so a sync
+//    implementation is required for parity. Verified in diagnostics
+//    against the two published NIST test vectors (empty string and "abc").
+// ═══════════════════════════════════════════════════════════════════════
+const SHA256_K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+function rotr(x: number, n: number): number {
+  return (x >>> n) | (x << (32 - n));
+}
+
+function sha256Bytes(bytes: Uint8Array): Uint8Array {
+  let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;
+  let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+
+  const bitLen = bytes.length * 8;
+  const padded = new Uint8Array((bytes.length + 9 + 63) & ~63);
+  padded.set(bytes);
+  padded[bytes.length] = 0x80;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 4, bitLen >>> 0, false);
+  view.setUint32(padded.length - 8, Math.floor(bitLen / 0x100000000), false);
+
+  const w = new Uint32Array(64);
+  for (let chunk = 0; chunk < padded.length; chunk += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(chunk + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+    }
+
+    let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const temp1 = (h + S1 + ch + SHA256_K[i] + w[i]) >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const temp2 = (S0 + maj) >>> 0;
+      h = g; g = f; f = e; e = (d + temp1) >>> 0;
+      d = c; c = b; b = a; a = (temp1 + temp2) >>> 0;
+    }
+
+    h0 = (h0 + a) >>> 0; h1 = (h1 + b) >>> 0; h2 = (h2 + c) >>> 0; h3 = (h3 + d) >>> 0;
+    h4 = (h4 + e) >>> 0; h5 = (h5 + f) >>> 0; h6 = (h6 + g) >>> 0; h7 = (h7 + h) >>> 0;
+  }
+
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  [h0, h1, h2, h3, h4, h5, h6, h7].forEach((h, i) => outView.setUint32(i * 4, h, false));
+  return out;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 1. Deterministic utilities — verbatim port of §1
+// ═══════════════════════════════════════════════════════════════════════
+export const ZERO_HASH = "0".repeat(64);
+export const STANDARD_METRICS = ["novelty", "utility", "tractability", "robustness", "taste"] as const;
+export type StandardMetric = (typeof STANDARD_METRICS)[number];
+
+export function utcNow(): string {
+  return new Date().toISOString();
+}
+
+export function canonicalJson(value: unknown): string {
+  const canon = (v: unknown): string => {
+    if (v === null || v === undefined) return "null";
+    if (typeof v === "number") return Number.isFinite(v) ? String(v) : "null";
+    if (typeof v === "boolean") return v ? "true" : "false";
+    if (typeof v === "string") return JSON.stringify(v);
+    if (Array.isArray(v)) return `[${v.map(canon).join(",")}]`;
+    if (typeof v === "object") {
+      const record = v as Record<string, unknown>;
+      const keys = Object.keys(record).sort();
+      return `{${keys.map((k) => `${JSON.stringify(k)}:${canon(record[k])}`).join(",")}}`;
+    }
+    return "null";
+  };
+  return canon(value);
+}
+
+export function sha256Text(value: string): string {
+  return bytesToHex(sha256Bytes(new TextEncoder().encode(value)));
+}
+
+/**
+ * derive_seed(*parts) — Python takes the first 8 bytes of sha256 as a
+ * big-endian *64-bit* unsigned integer. JS `number` only safely represents
+ * 53 bits, and the downstream `seedToGenome(seed: number)` from the V1
+ * engine already expects a 32-bit-range seed. Disclosed adaptation: this
+ * function truncates to the low 32 bits of that 64-bit value so it is a
+ * valid argument everywhere V1/V2 expect a `number` seed. The full 64-bit
+ * value remains available via `deriveSeedBigInt` for anyone who needs exact
+ * parity with the Python integer.
+ */
+export function deriveSeedBigInt(...parts: unknown[]): bigint {
+  const material = parts.map((p) => String(p)).join("|");
+  const digest = sha256Bytes(new TextEncoder().encode(material));
+  let value = 0n;
+  for (let i = 0; i < 8; i++) value = (value << 8n) | BigInt(digest[i]);
+  return value;
+}
+
+export function deriveSeed(...parts: unknown[]): number {
+  return Number(deriveSeedBigInt(...parts) % 4294967296n);
+}
+
+export function clamp01(value: number): number {
+  return Math.round(Math.max(0, Math.min(1, value)) * 10000) / 10000;
+}
+
+export function dimensionIds(): readonly string[] {
+  return DIMENSIONS.map((d) => d.id);
+}
+
+export function validateGenome(genome: Genome): void {
+  const expected = new Set(dimensionIds());
+  const actual = new Set(Object.keys(genome));
+
+  const missing = [...expected].filter((k) => !actual.has(k)).sort();
+  const extra = [...actual].filter((k) => !expected.has(k)).sort();
+
+  if (missing.length) throw new Error(`Genome missing dimensions: ${JSON.stringify(missing)}`);
+  if (extra.length) throw new Error(`Genome has unknown dimensions: ${JSON.stringify(extra)}`);
+
+  for (const [name, value] of Object.entries(genome)) {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      throw new TypeError(`Genome value ${JSON.stringify(name)} is not numeric`);
+    }
+    if (value < 0 || value > 1) {
+      throw new Error(`Genome value ${JSON.stringify(name)}=${value} outside [0,1]`);
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 2. Executable P/A/E/N/V/T/S graph-life scheduler — verbatim port of §2
+// ═══════════════════════════════════════════════════════════════════════
+export const NODE_LABELS: Readonly<Record<string, string>> = {
+  P: "Problem Choice and Framing",
+  A: "Anomaly Valuation",
+  E: "Embodiment and World Contact",
+  N: "Analogy and Representation Transfer",
+  V: "Evaluator Construction and Revision",
+  T: "Taste-Weighted Selection",
+  S: "Social Stabilization and Independent Review",
+};
+
+const NODE_ORDER = Object.keys(NODE_LABELS); // insertion order, matches Python dict iteration order
+
+export const NODE_GRAPH: Readonly<Record<string, ReadonlySet<string>>> = {
+  P: new Set(["A", "N", "V", "T", "S"]),
+  A: new Set(["P", "E", "N", "V", "T"]),
+  E: new Set(["P", "A", "V", "S"]),
+  N: new Set(["P", "A", "V", "T", "S"]),
+  V: new Set(["P", "A", "E", "N", "T", "S"]),
+  T: new Set(["P", "A", "N", "V", "S"]),
+  S: new Set(["P", "E", "N", "V", "T"]),
+};
+
+/** Finite operational forms of V1/V2 paths — ported verbatim, including deliberate node repeats (ρ, σ, τ, υ, ψ, ω represent loops). */
+export const PATH_NODES: Readonly<Record<string, readonly string[]>> = {
+  "α": ["P", "A", "E", "N", "V", "T", "S"],
+  "β": ["P", "N", "A", "V", "E", "T", "S"],
+  "γ": ["A", "P", "E", "V", "N", "T", "S"],
+  "δ": ["E", "A", "P", "N", "V", "T", "S"],
+  "ε": ["N", "P", "V", "A", "E", "T", "S"],
+  "ζ": ["T", "P", "A", "N", "V", "E", "S"],
+  "η": ["P", "V", "A", "E", "N", "T", "S"],
+  "θ": ["A", "N", "P", "V", "E", "T", "S"],
+  "ι": ["E", "P", "A", "V", "N", "T", "S"],
+  "κ": ["P", "A", "N", "V", "T", "E", "S"],
+  "λ": ["S", "P", "A", "E", "N", "V", "T"],
+  "μ": ["A", "E", "P", "V", "N", "T", "S"],
+  "ν": ["T", "A", "P", "N", "V", "E", "S"],
+  "ξ": ["N", "A", "V", "P", "E", "T", "S"],
+  "ο": ["P", "E", "A", "N", "V", "T", "S"],
+  "π": ["V", "P", "A", "E", "N", "T", "S"],
+  "ρ": ["P", "A", "V", "A", "V", "N", "T", "S"],
+  "σ": ["E", "A", "N", "V", "E", "A", "T", "S"],
+  "τ": ["T", "P", "A", "T", "N", "V", "E", "T", "S"],
+  "υ": ["P", "A", "E", "N", "V", "T", "S", "P"],
+  "φ": ["P", "N", "A", "V", "T", "E", "S"],
+  "χ": ["V", "P", "A", "E", "N", "T", "S"],
+  "ψ": ["P", "N", "N", "A", "V", "E", "T", "S"],
+  "ω": ["P", "A", "E", "N", "V", "T", "S", "S"],
+};
+
+const DEFAULT_PRIMARY: readonly string[] = ["P", "A", "E", "N", "V", "T", "S"];
+
+export interface StageWaveJSON {
+  tick: number;
+  nodes: string[];
+  labels: string[];
+  source: string;
+}
+
+export class StageWave {
+  constructor(
+    public readonly tick: number,
+    public readonly nodes: readonly string[],
+    public readonly source: string,
+  ) {
+    Object.freeze(this);
+  }
+
+  toDict(): StageWaveJSON {
+    return {
+      tick: this.tick,
+      nodes: [...this.nodes],
+      labels: this.nodes.map((n) => NODE_LABELS[n]),
+      source: this.source,
+    };
+  }
+}
+
+export class GraphLifeScheduler {
+  readonly seed: number;
+  readonly genome: Genome;
+  readonly pathId: string;
+  readonly primary: readonly string[];
+
+  constructor(seed: number, genome: Genome, pathId: string) {
+    validateGenome(genome);
+    this.seed = seed;
+    this.genome = { ...genome };
+    this.pathId = pathId;
+    this.primary = PATH_NODES[pathId] ?? DEFAULT_PRIMARY;
+  }
+
+  private initialAlive(): Set<string> {
+    const digest = sha256Bytes(new TextEncoder().encode(`graph-life:${this.seed}:${this.pathId}`));
+    const alive = new Set<string>();
+    NODE_ORDER.forEach((node, index) => {
+      if (digest[index] & 1) alive.add(node);
+    });
+    alive.add(this.primary[0]);
+    return alive;
+  }
+
+  build(maxTicks = 7): StageWave[] {
+    if (maxTicks < 1) throw new Error("maxTicks must be >= 1");
+
+    let alive = this.initialAlive();
+    const seenStates = new Set<string>();
+    const visited = new Set<string>();
+    const waves: StageWave[] = [];
+
+    const birthThreshold = this.genome.portfolio_breadth >= 0.67 ? 3 : 2;
+    const survivalMax = this.genome.mechanism_independence >= 0.67 ? 4 : 3;
+
+    const primaryRank = new Map<string, number>();
+    this.primary.forEach((node, index) => {
+      if (!primaryRank.has(node)) primaryRank.set(node, index);
+    });
+
+    for (let tick = 0; tick < maxTicks; tick++) {
+      const state = [...alive].sort().join(",");
+      if (seenStates.has(state)) break;
+      seenStates.add(state);
+
+      const ordered = [...alive].sort((a, b) => {
+        const ra = primaryRank.get(a) ?? 10_000;
+        const rb = primaryRank.get(b) ?? 10_000;
+        if (ra !== rb) return ra - rb;
+        return a < b ? -1 : a > b ? 1 : 0;
+      });
+
+      if (ordered.length > 0) {
+        waves.push(new StageWave(tick, ordered, "graph-life"));
+        ordered.forEach((n) => visited.add(n));
+      }
+
+      const nextAlive = new Set<string>();
+      for (const node of NODE_ORDER) {
+        let liveNeighbors = 0;
+        for (const neighbor of NODE_GRAPH[node]) if (alive.has(neighbor)) liveNeighbors++;
+
+        if (alive.has(node)) {
+          if (liveNeighbors >= 1 && liveNeighbors <= survivalMax) nextAlive.add(node);
+        } else if (liveNeighbors === birthThreshold) {
+          nextAlive.add(node);
+        }
+      }
+
+      const nextRequired = this.primary.find((n) => !visited.has(n));
+      if (nextRequired !== undefined) nextAlive.add(nextRequired);
+
+      alive = nextAlive;
+    }
+
+    let nextTick = waves.length;
+    for (const node of this.primary) {
+      if (!visited.has(node)) {
+        waves.push(new StageWave(nextTick, [node], "path-coverage"));
+        visited.add(node);
+        nextTick += 1;
+      }
+    }
+
+    return waves;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 3. Versioned goals, evaluator contracts, candidates and reports —
+//    verbatim port of §3
+// ═══════════════════════════════════════════════════════════════════════
+export interface GoalSpecInit {
+  version: number;
+  statement: string;
+  successCriteria: readonly string[];
+  hardConstraints: readonly string[];
+  softObjectives?: readonly string[];
+  parentHash?: string;
+  rationale?: string;
+  approvals?: readonly string[];
+}
+
+export class GoalSpec {
+  readonly version: number;
+  readonly statement: string;
+  readonly successCriteria: readonly string[];
+  readonly hardConstraints: readonly string[];
+  readonly softObjectives: readonly string[];
+  readonly parentHash: string;
+  readonly rationale: string;
+  readonly approvals: readonly string[];
+
+  constructor(init: GoalSpecInit) {
+    this.version = init.version;
+    this.statement = init.statement;
+    this.successCriteria = init.successCriteria;
+    this.hardConstraints = init.hardConstraints;
+    this.softObjectives = init.softObjectives ?? [];
+    this.parentHash = init.parentHash ?? "";
+    this.rationale = init.rationale ?? "initial goal";
+    this.approvals = init.approvals ?? [];
+  }
+
+  validate(): void {
+    if (this.version < 1) throw new Error("Goal version must be >= 1");
+    if (!this.statement.trim()) throw new Error("Goal statement is empty");
+    if (this.successCriteria.length === 0) throw new Error("Goal must contain success criteria");
+    if (this.hardConstraints.length === 0) throw new Error("Goal must contain hard constraints");
+  }
+
+  get contentHash(): string {
+    return sha256Text(
+      canonicalJson({
+        version: this.version,
+        statement: this.statement,
+        success_criteria: this.successCriteria,
+        hard_constraints: this.hardConstraints,
+        soft_objectives: this.softObjectives,
+        parent_hash: this.parentHash,
+        rationale: this.rationale,
+        approvals: this.approvals,
+      }),
+    );
+  }
+
+  static fromDict(raw: Record<string, unknown>): GoalSpec {
+    return new GoalSpec({
+      version: Number(raw.version),
+      statement: String(raw.statement),
+      successCriteria: [...(raw.success_criteria as string[])],
+      hardConstraints: [...(raw.hard_constraints as string[])],
+      softObjectives: [...((raw.soft_objectives as string[]) ?? [])],
+      parentHash: String(raw.parent_hash ?? ""),
+      rationale: String(raw.rationale ?? ""),
+      approvals: [...((raw.approvals as string[]) ?? [])],
+    });
+  }
+}
+
+export interface EvaluatorSpecInit {
+  version: number;
+  metrics?: readonly string[];
+  hardGates?: readonly string[];
+  parentHash?: string;
+  rationale?: string;
+}
+
+export class EvaluatorSpec {
+  readonly version: number;
+  readonly metrics: readonly string[];
+  readonly hardGates: readonly string[];
+  readonly parentHash: string;
+  readonly rationale: string;
+
+  constructor(init: EvaluatorSpecInit) {
+    this.version = init.version;
+    this.metrics = init.metrics ?? STANDARD_METRICS;
+    this.hardGates = init.hardGates ?? ["correctness", "scope", "evidence", "safety"];
+    this.parentHash = init.parentHash ?? "";
+    this.rationale = init.rationale ?? "initial evaluator";
+  }
+
+  validate(): void {
+    if (this.version < 1) throw new Error("Evaluator version must be >= 1");
+    if (this.metrics.length === 0) throw new Error("Evaluator must define metrics");
+    if (new Set(this.metrics).size !== this.metrics.length) throw new Error("Evaluator metrics contain duplicates");
+    if (this.hardGates.length === 0) throw new Error("Evaluator must define hard gates");
+    if (new Set(this.hardGates).size !== this.hardGates.length) throw new Error("Evaluator hard gates contain duplicates");
+  }
+
+  get contentHash(): string {
+    return sha256Text(
+      canonicalJson({
+        version: this.version,
+        metrics: this.metrics,
+        hard_gates: this.hardGates,
+        parent_hash: this.parentHash,
+        rationale: this.rationale,
+      }),
+    );
+  }
+
+  static fromDict(raw: Record<string, unknown>): EvaluatorSpec {
+    return new EvaluatorSpec({
+      version: Number(raw.version),
+      metrics: [...(raw.metrics as string[])],
+      hardGates: [...(raw.hard_gates as string[])],
+      parentHash: String(raw.parent_hash ?? ""),
+      rationale: String(raw.rationale ?? ""),
+    });
+  }
+}
+
+export interface GenerationRequest {
+  runId: string;
+  epoch: number;
+  candidateIndex: number;
+  candidateSeed: number;
+  goal: GoalSpec;
+  evaluatorSpec: EvaluatorSpec;
+  genome: Genome;
+  persona: { name: string; tagline: string };
+  path: { id: string; name: string; seq: string };
+  schedule: readonly StageWave[];
+  prompt: string;
+}
+
+export interface CandidateJSON {
+  candidate_id: string;
+  run_id: string;
+  epoch: number;
+  candidate_index: number;
+  candidate_seed: number;
+  goal_hash: string;
+  evaluator_hash: string;
+  genome: Genome;
+  persona: Record<string, string>;
+  path: Record<string, string>;
+  schedule: StageWaveJSON[];
+  artifact: string;
+  producer_name: string;
+  producer_family: string;
+  parent_ids: string[];
+  mutation_rationale: string;
+  artifact_hash: string;
+}
+
+export class BlindCandidate {
+  constructor(
+    public readonly candidateId: string,
+    public readonly runId: string,
+    public readonly epoch: number,
+    public readonly goalHash: string,
+    public readonly evaluatorHash: string,
+    public readonly genome: Genome,
+    public readonly artifact: string,
+    public readonly artifactHash: string,
+  ) {}
+}
+
+export class Candidate {
+  constructor(
+    public readonly candidateId: string,
+    public readonly runId: string,
+    public readonly epoch: number,
+    public readonly candidateIndex: number,
+    public readonly candidateSeed: number,
+    public readonly goalHash: string,
+    public readonly evaluatorHash: string,
+    public readonly genome: Genome,
+    public readonly persona: { name: string; tagline: string },
+    public readonly path: { id: string; name: string; seq: string },
+    public readonly schedule: readonly StageWave[],
+    public readonly artifact: string,
+    public readonly producerName: string,
+    public readonly producerFamily: string,
+    public readonly parentIds: readonly string[],
+    public readonly mutationRationale: string,
+    public readonly artifactHash: string,
+  ) {}
+
+  /** Evaluator-family separation: strips producer identity, persona, and path from what the evaluator sees, so evaluators cannot exhibit self-preference toward a producer they recognize. */
+  blind(): BlindCandidate {
+    return new BlindCandidate(
+      this.candidateId,
+      this.runId,
+      this.epoch,
+      this.goalHash,
+      this.evaluatorHash,
+      { ...this.genome },
+      this.artifact,
+      this.artifactHash,
+    );
+  }
+
+  toDict(): CandidateJSON {
+    return {
+      candidate_id: this.candidateId,
+      run_id: this.runId,
+      epoch: this.epoch,
+      candidate_index: this.candidateIndex,
+      candidate_seed: this.candidateSeed,
+      goal_hash: this.goalHash,
+      evaluator_hash: this.evaluatorHash,
+      genome: { ...this.genome },
+      persona: { ...this.persona },
+      path: { ...this.path },
+      schedule: this.schedule.map((w) => w.toDict()),
+      artifact: this.artifact,
+      producer_name: this.producerName,
+      producer_family: this.producerFamily,
+      parent_ids: [...this.parentIds],
+      mutation_rationale: this.mutationRationale,
+      artifact_hash: this.artifactHash,
+    };
+  }
+}
+
+export interface EvaluationReportInit {
+  candidateId: string;
+  evaluatorId: string;
+  evaluatorFamily: string;
+  evaluatorSpecHash: string;
+  metrics: Record<string, number>;
+  hardGates: Record<string, boolean>;
+  confidence: number;
+  evidence: readonly string[];
+  actionableInformation?: readonly string[];
+  anomalies?: readonly string[];
+}
+
+export class EvaluationReport {
+  readonly candidateId: string;
+  readonly evaluatorId: string;
+  readonly evaluatorFamily: string;
+  readonly evaluatorSpecHash: string;
+  readonly metrics: Record<string, number>;
+  readonly hardGates: Record<string, boolean>;
+  readonly confidence: number;
+  readonly evidence: readonly string[];
+  readonly actionableInformation: readonly string[];
+  readonly anomalies: readonly string[];
+
+  constructor(init: EvaluationReportInit) {
+    this.candidateId = init.candidateId;
+    this.evaluatorId = init.evaluatorId;
+    this.evaluatorFamily = init.evaluatorFamily;
+    this.evaluatorSpecHash = init.evaluatorSpecHash;
+    this.metrics = { ...init.metrics };
+    this.hardGates = { ...init.hardGates };
+    this.confidence = init.confidence;
+    this.evidence = init.evidence;
+    this.actionableInformation = init.actionableInformation ?? [];
+    this.anomalies = init.anomalies ?? [];
+  }
+
+  validate(candidateId: string, spec: EvaluatorSpec): void {
+    if (this.candidateId !== candidateId) throw new Error("Evaluator returned wrong candidate_id");
+    if (this.evaluatorSpecHash !== spec.contentHash) throw new Error("Evaluator used a different evaluator specification");
+
+    const missingMetrics = spec.metrics.filter((m) => !(m in this.metrics)).sort();
+    if (missingMetrics.length) throw new Error(`Evaluator omitted metrics: ${JSON.stringify(missingMetrics)}`);
+
+    const missingGates = spec.hardGates.filter((g) => !(g in this.hardGates)).sort();
+    if (missingGates.length) throw new Error(`Evaluator omitted hard gates: ${JSON.stringify(missingGates)}`);
+
+    for (const name of spec.metrics) {
+      const value = this.metrics[name];
+      if (value < 0 || value > 1) throw new Error(`Metric ${JSON.stringify(name)}=${value} outside [0,1]`);
+    }
+
+    if (this.confidence < 0 || this.confidence > 1) throw new Error("Evaluator confidence outside [0,1]");
+  }
+}
+
+export interface AggregateReportInit {
+  candidateId: string;
+  evaluatorSpecHash: string;
+  metrics: Record<string, number>;
+  metricSpread: Record<string, number>;
+  hardGates: Record<string, boolean>;
+  confidence: number;
+  evidence: readonly string[];
+  actionableInformation: readonly string[];
+  anomalies: readonly string[];
+  evaluatorIds: readonly string[];
+  errors: readonly string[];
+  verified: boolean;
+  reports: readonly EvaluationReport[];
+}
+
+export class AggregateReport {
+  readonly candidateId: string;
+  readonly evaluatorSpecHash: string;
+  readonly metrics: Record<string, number>;
+  readonly metricSpread: Record<string, number>;
+  readonly hardGates: Record<string, boolean>;
+  readonly confidence: number;
+  readonly evidence: readonly string[];
+  readonly actionableInformation: readonly string[];
+  readonly anomalies: readonly string[];
+  readonly evaluatorIds: readonly string[];
+  readonly errors: readonly string[];
+  readonly verified: boolean;
+  readonly reports: readonly EvaluationReport[];
+
+  constructor(init: AggregateReportInit) {
+    Object.assign(this, init);
+    this.candidateId = init.candidateId;
+    this.evaluatorSpecHash = init.evaluatorSpecHash;
+    this.metrics = { ...init.metrics };
+    this.metricSpread = { ...init.metricSpread };
+    this.hardGates = { ...init.hardGates };
+    this.confidence = init.confidence;
+    this.evidence = init.evidence;
+    this.actionableInformation = init.actionableInformation;
+    this.anomalies = init.anomalies;
+    this.evaluatorIds = init.evaluatorIds;
+    this.errors = init.errors;
+    this.verified = init.verified;
+    this.reports = init.reports;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 4. External adapter contracts — verbatim port of §4
+// ═══════════════════════════════════════════════════════════════════════
+export interface ToolRegistryLike {
+  callTool(name: string, args: readonly string[]): Promise<{ stdout: string; stderr: string; exitCode: number }>;
+}
+
+export interface CandidateProducer {
+  name: string;
+  family: string;
+  produce(request: GenerationRequest, tools: ToolRegistryLike): Promise<string> | string;
+}
+
+export interface CandidateEvaluator {
+  name: string;
+  family: string;
+  spec: EvaluatorSpec;
+  evaluate(candidate: BlindCandidate, goal: GoalSpec, tools: ToolRegistryLike): Promise<EvaluationReport> | EvaluationReport;
+}
+
+export class FunctionProducer implements CandidateProducer {
+  constructor(
+    public readonly name: string,
+    public readonly family: string,
+    private readonly fn: (request: GenerationRequest, tools: ToolRegistryLike) => Promise<string> | string,
+  ) {}
+  produce(request: GenerationRequest, tools: ToolRegistryLike) {
+    return this.fn(request, tools);
+  }
+}
+
+export class FunctionEvaluator implements CandidateEvaluator {
+  constructor(
+    public readonly name: string,
+    public readonly family: string,
+    public readonly spec: EvaluatorSpec,
+    private readonly fn: (candidate: BlindCandidate, goal: GoalSpec, tools: ToolRegistryLike) => Promise<EvaluationReport> | EvaluationReport,
+  ) {}
+  evaluate(candidate: BlindCandidate, goal: GoalSpec, tools: ToolRegistryLike) {
+    return this.fn(candidate, goal, tools);
+  }
+}
+
+export interface ReviewDecision {
+  approved: boolean;
+  reference: string;
+  rationale: string;
+}
+
+export interface GoalProposer {
+  name: string;
+  propose(currentGoal: GoalSpec, epochTrace: readonly Record<string, unknown>[]): GoalSpec | null;
+}
+
+export interface GoalReviewer {
+  name: string;
+  review(currentGoal: GoalSpec, proposedGoal: GoalSpec): ReviewDecision;
+}
+
+export interface EvaluatorProposer {
+  name: string;
+  propose(
+    currentSpec: EvaluatorSpec,
+    epochTrace: readonly Record<string, unknown>[],
+  ): [EvaluatorSpec, readonly CandidateEvaluator[]] | null;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 5. Goal and evaluator mutation policies — verbatim port of §5
+// ═══════════════════════════════════════════════════════════════════════
+export interface GoalMutationPolicyOptions {
+  minimumApprovals?: number;
+  requireHumanApproval?: boolean;
+}
+
+export class GoalMutationPolicy {
+  readonly minimumApprovals: number;
+  readonly requireHumanApproval: boolean;
+
+  constructor(options: GoalMutationPolicyOptions = {}) {
+    this.minimumApprovals = options.minimumApprovals ?? 1;
+    this.requireHumanApproval = options.requireHumanApproval ?? false;
+  }
+
+  validate(parent: GoalSpec, proposed: GoalSpec, atEpochBoundary: boolean): string[] {
+    const errors: string[] = [];
+
+    if (!atEpochBoundary) errors.push("Goal mutation attempted inside an epoch");
+    if (proposed.version !== parent.version + 1) errors.push("Goal version must increment exactly once");
+    if (proposed.parentHash !== parent.contentHash) errors.push("Goal parent_hash does not match current goal");
+    if (!proposed.rationale.trim()) errors.push("Goal mutation lacks rationale");
+
+    const parentConstraints = new Set(parent.hardConstraints);
+    const proposedConstraints = new Set(proposed.hardConstraints);
+    for (const c of parentConstraints) {
+      if (!proposedConstraints.has(c)) {
+        errors.push("Goal mutation removed a hard constraint");
+        break;
+      }
+    }
+
+    if (proposed.approvals.length < this.minimumApprovals) errors.push("Goal mutation lacks sufficient approvals");
+
+    if (this.requireHumanApproval && !proposed.approvals.some((a) => a.startsWith("human:"))) {
+      errors.push("High-stakes goal mutation lacks human approval");
+    }
+
+    try {
+      proposed.validate();
+    } catch (exc) {
+      errors.push(exc instanceof Error ? exc.message : String(exc));
+    }
+
+    return errors;
+  }
+}
+
+export interface CalibrationCase {
+  artifact: string;
+  expectedHardGates: Record<string, boolean>;
+}
+
+export async function calibrateEvaluator(
+  evaluator: CandidateEvaluator,
+  cases: readonly CalibrationCase[],
+  goal: GoalSpec,
+  tools: ToolRegistryLike,
+): Promise<number> {
+  if (cases.length === 0) throw new Error("Evaluator calibration requires at least one case");
+
+  let correct = 0;
+  let total = 0;
+
+  for (let index = 0; index < cases.length; index++) {
+    const testCase = cases[index];
+    const artifactHash = sha256Text(testCase.artifact);
+    const candidate = new BlindCandidate(
+      `calibration-${index}-${artifactHash.slice(0, 12)}`,
+      "calibration",
+      -1,
+      goal.contentHash,
+      evaluator.spec.contentHash,
+      seedToGenome(index),
+      testCase.artifact,
+      artifactHash,
+    );
+
+    const report = await evaluator.evaluate(candidate, goal, tools);
+    report.validate(candidate.candidateId, evaluator.spec);
+
+    for (const [gate, expected] of Object.entries(testCase.expectedHardGates)) {
+      if (!(gate in report.hardGates)) {
+        total += 1;
+        continue;
+      }
+      correct += report.hardGates[gate] === expected ? 1 : 0;
+      total += 1;
+    }
+  }
+
+  return correct / Math.max(1, total);
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 6. Budget accounting — verbatim port of §6
+// ═══════════════════════════════════════════════════════════════════════
+export class BudgetExceeded extends Error {}
+
+export interface BudgetLimitsInit {
+  candidates?: number;
+  evaluatorCalls?: number;
+  toolCalls?: number;
+  worldActions?: number;
+  reportedTokens?: number;
+}
+
+export class BudgetLimits {
+  readonly candidates: number;
+  readonly evaluatorCalls: number;
+  readonly toolCalls: number;
+  readonly worldActions: number;
+  readonly reportedTokens: number;
+
+  constructor(init: BudgetLimitsInit = {}) {
+    this.candidates = init.candidates ?? 32;
+    this.evaluatorCalls = init.evaluatorCalls ?? 128;
+    this.toolCalls = init.toolCalls ?? 128;
+    this.worldActions = init.worldActions ?? 32;
+    this.reportedTokens = init.reportedTokens ?? 2_000_000;
+  }
+}
+
+type BudgetResource = "candidates" | "evaluatorCalls" | "toolCalls" | "worldActions" | "reportedTokens";
+
+export class BudgetState {
+  candidates = 0;
+  evaluatorCalls = 0;
+  toolCalls = 0;
+  worldActions = 0;
+  reportedTokens = 0;
+
+  constructor(public readonly limits: BudgetLimits) {}
+
+  consume(resource: BudgetResource, amount = 1): void {
+    if (amount < 0) throw new Error("Budget consumption cannot be negative");
+    const validResources: BudgetResource[] = ["candidates", "evaluatorCalls", "toolCalls", "worldActions", "reportedTokens"];
+    if (!validResources.includes(resource)) throw new Error(`Unknown budget resource ${JSON.stringify(resource)}`);
+
+    const current = this[resource];
+    const limit = this.limits[resource];
+
+    if (current + amount > limit) {
+      throw new BudgetExceeded(`${resource} budget exceeded: ${current}+${amount}>${limit}`);
+    }
+
+    this[resource] = current + amount;
+  }
+
+  toDict(): Record<string, unknown> {
+    return {
+      limits: {
+        candidates: this.limits.candidates,
+        evaluator_calls: this.limits.evaluatorCalls,
+        tool_calls: this.limits.toolCalls,
+        world_actions: this.limits.worldActions,
+        reported_tokens: this.limits.reportedTokens,
+      },
+      candidates: this.candidates,
+      evaluator_calls: this.evaluatorCalls,
+      tool_calls: this.toolCalls,
+      world_actions: this.worldActions,
+      reported_tokens: this.reportedTokens,
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 7. Tamper-evident, hash-chained event/memory/checkpoint store
+// ---------------------------------------------------------------------
+// DISCLOSED ADAPTATION (see file header): the Python spec used SQLite,
+// which does not exist in a browser runtime. The hash-chain ALGORITHM given
+// in the legible parts of §7 (event_hash = sha256(canonical_json({run_id,
+// created_utc, kind, payload_json, prev_hash})); verify_chain walks rows
+// checking prev_hash continuity and re-deriving each hash) is reproduced
+// exactly, over an in-memory array persisted to localStorage instead of a
+// .sqlite file, so the tamper-evidence property is real and testable.
+// ═══════════════════════════════════════════════════════════════════════
+interface EventRow {
+  runId: string;
+  seq: number;
+  createdUtc: string;
+  kind: string;
+  payloadJson: string;
+  prevHash: string;
+  eventHash: string;
+}
+
+interface CheckpointRow {
+  runId: string;
+  name: string;
+  createdUtc: string;
+  eventSeq: number;
+  stateJson: string;
+  stateHash: string;
+}
+
+interface MemoryRow {
+  memoryId: string;
+  runId: string;
+  kind: string;
+  status: "open" | "resolved";
+  priority: number;
+  payloadJson: string;
+  createdSeq: number;
+  updatedSeq: number;
+}
+
+interface RunRow {
+  runId: string;
+  createdUtc: string;
+  seed: number;
+  domain: string;
+  risk: RiskTier;
+  status: string;
+  configJson: string;
+}
+
+export class EventStore {
+  private runs = new Map<string, RunRow>();
+  private events: EventRow[] = [];
+  private checkpoints: CheckpointRow[] = [];
+  private memories: MemoryRow[] = [];
+  private nextSeq = 1;
+
+  constructor(private readonly persistenceKey: string | null = null) {
+    if (this.persistenceKey) this.loadFromStorage();
+  }
+
+  private loadFromStorage(): void {
+    try {
+      const raw = typeof localStorage !== "undefined" ? localStorage.getItem(this.persistenceKey!) : null;
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      this.runs = new Map(parsed.runs ?? []);
+      this.events = parsed.events ?? [];
+      this.checkpoints = parsed.checkpoints ?? [];
+      this.memories = parsed.memories ?? [];
+      this.nextSeq = parsed.nextSeq ?? 1;
+    } catch {
+      /* corrupted or absent storage — start fresh, never crash */
+    }
+  }
+
+  private persist(): void {
+    if (!this.persistenceKey || typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(
+        this.persistenceKey,
+        JSON.stringify({
+          runs: [...this.runs.entries()],
+          events: this.events,
+          checkpoints: this.checkpoints,
+          memories: this.memories,
+          nextSeq: this.nextSeq,
+        }),
+      );
+    } catch {
+      /* storage full/unavailable — the in-memory chain remains authoritative for this session */
+    }
+  }
+
+  createRun(runId: string, seed: number, domain: string, risk: RiskTier, config: Record<string, unknown>): void {
+    this.runs.set(runId, {
+      runId,
+      createdUtc: utcNow(),
+      seed,
+      domain,
+      risk,
+      status: "running",
+      configJson: canonicalJson(config),
+    });
+    this.appendEvent(runId, "run_created", { seed, domain, risk });
+  }
+
+  setRunStatus(runId: string, status: string): void {
+    const run = this.runs.get(runId);
+    if (run) run.status = status;
+    this.persist();
+  }
+
+  /** Exact hash-chain material and algorithm from the legible part of §7. */
+  appendEvent(runId: string, kind: string, payload: Record<string, unknown>): number {
+    const payloadJson = canonicalJson(payload);
+    const created = utcNow();
+
+    const priorForRun = this.events.filter((e) => e.runId === runId);
+    const prevHash = priorForRun.length > 0 ? priorForRun[priorForRun.length - 1].eventHash : ZERO_HASH;
+
+    const material = canonicalJson({
+      run_id: runId,
+      created_utc: created,
+      kind,
+      payload_json: payloadJson,
+      prev_hash: prevHash,
+    });
+    const eventHash = sha256Text(material);
+
+    const seq = this.nextSeq++;
+    this.events.push({ runId, seq, createdUtc: created, kind, payloadJson, prevHash, eventHash });
+    this.persist();
+    return seq;
+  }
+
+  /**
+   * Protected accessor so V4+ subclasses can re-derive their own chains from
+   * the REAL stored payloads (not just link continuity). Additive: nothing
+   * that already existed is changed.
+   */
+  protected eventRowsForRun(runId: string): ReadonlyArray<{
+    runId: string;
+    seq: number;
+    createdUtc: string;
+    kind: string;
+    payloadJson: string;
+    prevHash: string;
+    eventHash: string;
+  }> {
+    return this.events.filter((e) => e.runId === runId).sort((a, b) => a.seq - b.seq);
+  }
+
+  /** Test-only tamper hook: mutates a stored payload so chain verifiers can be proven to detect it. */
+  _tamperPayloadForTest(runId: string, kind: string, newPayloadJson: string): boolean {
+    const row = this.events.find((e) => e.runId === runId && e.kind === kind);
+    if (!row) return false;
+    row.payloadJson = newPayloadJson;
+    return true;
+  }
+
+  verifyChain(runId: string): boolean {
+    const rows = this.events.filter((e) => e.runId === runId).sort((a, b) => a.seq - b.seq);
+    let expectedPrev = ZERO_HASH;
+
+    for (const row of rows) {
+      if (row.prevHash !== expectedPrev) return false;
+
+      const material = canonicalJson({
+        run_id: row.runId,
+        created_utc: row.createdUtc,
+        kind: row.kind,
+        payload_json: row.payloadJson,
+        prev_hash: row.prevHash,
+      });
+      if (sha256Text(material) !== row.eventHash) return false;
+
+      expectedPrev = row.eventHash;
+    }
+
+    return true;
+  }
+
+  saveCheckpoint(runId: string, name: string, state: Record<string, unknown>): string {
+    const eventsForRun = this.events.filter((e) => e.runId === runId);
+    const eventSeq = eventsForRun.length > 0 ? eventsForRun[eventsForRun.length - 1].seq : 0;
+    const stateJson = canonicalJson(state);
+    const stateHash = sha256Text(stateJson);
+
+    this.checkpoints = this.checkpoints.filter((c) => !(c.runId === runId && c.name === name));
+    this.checkpoints.push({ runId, name, createdUtc: utcNow(), eventSeq, stateJson, stateHash });
+
+    this.appendEvent(runId, "checkpoint_saved", { name, event_seq: eventSeq, state_hash: stateHash });
+    return stateHash;
+  }
+
+  loadCheckpoint(runId: string, name: string): Record<string, unknown> {
+    const row = this.checkpoints.find((c) => c.runId === runId && c.name === name);
+    if (!row) throw new Error(`Checkpoint ${JSON.stringify(name)} does not exist`);
+    if (sha256Text(row.stateJson) !== row.stateHash) throw new Error("Checkpoint hash mismatch");
+    return JSON.parse(row.stateJson);
+  }
+
+  /** Internal accessor used by MemoryLedger — kept private-by-convention (not exported). */
+  _memories(): MemoryRow[] {
+    return this.memories;
+  }
+  _addMemoryRow(row: MemoryRow): void {
+    this.memories.push(row);
+    this.persist();
+  }
+  _updateMemoryRow(memoryId: string, runId: string, payloadJson: string, updatedSeq: number): void {
+    const row = this.memories.find((m) => m.memoryId === memoryId && m.runId === runId);
+    if (row) {
+      row.payloadJson = payloadJson;
+      row.status = "resolved";
+      row.updatedSeq = updatedSeq;
+    }
+    this.persist();
+  }
+}
+
+export class MemoryLedger {
+  constructor(
+    private readonly store: EventStore,
+    private readonly runId: string,
+  ) {}
+
+  add(kind: string, payload: Record<string, unknown>, priority: number): string {
+    if (priority < 0 || priority > 1) throw new Error("Memory priority outside [0,1]");
+
+    const createdSeq = this.store.appendEvent(this.runId, "memory_added", { kind, priority, payload: { ...payload } });
+
+    const memoryId = sha256Text(
+      canonicalJson({ run_id: this.runId, kind, payload, created_seq: createdSeq }),
+    );
+
+    this.store._addMemoryRow({
+      memoryId,
+      runId: this.runId,
+      kind,
+      status: "open",
+      priority,
+      payloadJson: canonicalJson(payload),
+      createdSeq,
+      updatedSeq: createdSeq,
+    });
+
+    return memoryId;
+  }
+
+  resolve(memoryId: string, resolution: Record<string, unknown>): void {
+    const seq = this.store.appendEvent(this.runId, "memory_resolved", { memory_id: memoryId, resolution: { ...resolution } });
+
+    const row = this.store._memories().find((m) => m.memoryId === memoryId && m.runId === this.runId);
+    if (!row) throw new Error(memoryId);
+
+    const payload = JSON.parse(row.payloadJson);
+    payload.resolution = { ...resolution };
+
+    this.store._updateMemoryRow(memoryId, this.runId, canonicalJson(payload), seq);
+  }
+
+  listOpen(options: { kinds?: readonly string[]; limit?: number } = {}): Array<Record<string, unknown>> {
+    const limit = options.limit ?? 10;
+    if (limit < 1) return [];
+
+    let rows = this.store._memories().filter((m) => m.runId === this.runId && m.status === "open");
+    if (options.kinds && options.kinds.length > 0) {
+      const kindSet = new Set(options.kinds);
+      rows = rows.filter((r) => kindSet.has(r.kind));
+    }
+
+    rows = rows.sort((a, b) => b.priority - a.priority || a.createdSeq - b.createdSeq);
+
+    return rows.slice(0, limit).map((r) => ({
+      memory_id: r.memoryId,
+      kind: r.kind,
+      priority: r.priority,
+      payload: JSON.parse(r.payloadJson),
+    }));
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 8. Browser-safe tool registry
+// ---------------------------------------------------------------------
+// DISCLOSED ADAPTATION: the pasted spec's docstring says "Local subprocess
+// adapter" with security properties "shell=False, exact allowlist, fixed
+// working directory, timeout, bounded captured output" — but arbitrary
+// subprocess execution is categorically unavailable and unsafe inside a
+// Vite single-page browser bundle (there is no child_process, no shell, no
+// filesystem). Faithfully translating the STATED SECURITY PROPERTIES rather
+// than the impossible mechanism: this registry (a) never invokes a shell,
+// (b) only runs functions from a fixed, explicit allowlist supplied at
+// construction, (c) enforces a timeout via Promise.race, (d) truncates
+// captured output to a bounded byte length, and (e) is fully budget-gated
+// through BudgetState, exactly like the Python tool-call accounting.
+// ═══════════════════════════════════════════════════════════════════════
+export type ToolFunction = (args: readonly string[]) => Promise<string> | string;
+
+export interface ToolRegistryOptions {
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+}
+
+export class ToolRegistry implements ToolRegistryLike {
+  private readonly allowlist = new Map<string, ToolFunction>();
+  private readonly timeoutMs: number;
+  private readonly maxOutputBytes: number;
+
+  constructor(
+    public readonly capabilityGate: CapabilityGate,
+    private readonly budget: BudgetState,
+    options: ToolRegistryOptions = {},
+  ) {
+    this.timeoutMs = options.timeoutMs ?? 5_000;
+    this.maxOutputBytes = options.maxOutputBytes ?? 65_536;
+  }
+
+  register(name: string, fn: ToolFunction): void {
+    this.allowlist.set(name, fn);
+  }
+
+  async callTool(name: string, args: readonly string[]): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+    this.budget.consume("toolCalls", 1);
+
+    const fn = this.allowlist.get(name);
+    if (!fn) {
+      return { stdout: "", stderr: `tool not in allowlist: ${JSON.stringify(name)}`, exitCode: 127 };
+    }
+
+    try {
+      const timeout = new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error(`tool ${name} timed out after ${this.timeoutMs}ms`)), this.timeoutMs);
+      });
+      const stdout = await Promise.race([Promise.resolve(fn(args)), timeout]);
+      return { stdout: stdout.slice(0, this.maxOutputBytes), stderr: "", exitCode: 0 };
+    } catch (error) {
+      return { stdout: "", stderr: error instanceof Error ? error.message : String(error), exitCode: 1 };
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 9. Seven-dimensional descriptor + versioned MAP-Elites archive
+// ---------------------------------------------------------------------
+// DISCLOSED: the docstrings survived ("Seven-dimensional descriptor based
+// on V1 discovery blocks", "MAP-Elites style archive with versioning
+// logic... Scores are never compared across materially different Goal or
+// Evaluator specifications (The Versioning Invariant)") but the method
+// bodies did not. Implemented in full below, functioning and non-mocked:
+// the descriptor buckets each of V1's 7 discovery blocks (Problem Choice,
+// Anomaly Valuation, Embodiment, Analogy, Evaluator Revision, Taste, Social
+// Stabilization) into a coarse decile via the mean of that block's genome
+// dimensions, and the archive enforces the Versioning Invariant by keying
+// every bucket on `${goalHash}:${evaluatorSpecHash}` so scores under a
+// mutated Goal or Evaluator can never silently overwrite or compare against
+// scores from a materially different specification.
+// ═══════════════════════════════════════════════════════════════════════
+export function sevenDimensionalDescriptor(genome: Genome): readonly number[] {
+  return Object.keys(DIMENSION_BLOCKS).map((block) => {
+    const ids = DIMENSION_BLOCKS[block];
+    const mean = ids.reduce((sum, id) => sum + (genome[id] ?? 0), 0) / Math.max(1, ids.length);
+    return Math.floor(clamp01(mean) * 10); // decile bucket: 0-10
+  });
+}
+
+export interface ArchiveEntry {
+  candidate: Candidate;
+  report: AggregateReport;
+  descriptor: readonly number[];
+}
+
+function scoreOf(report: AggregateReport): number {
+  const values = Object.values(report.metrics);
+  return values.length ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+}
+
+export class VersionedArchive {
+  readonly buckets = new Map<string, Map<string, ArchiveEntry>>();
+
+  private contextKey(goalHash: string, evaluatorSpecHash: string): string {
+    return `${goalHash}:${evaluatorSpecHash}`;
+  }
+
+  private cellKey(descriptor: readonly number[]): string {
+    return descriptor.join(".");
+  }
+
+  /** The Versioning Invariant: a candidate can only ever be compared to prior entries under the SAME (goalHash, evaluatorSpecHash) context. */
+  add(candidate: Candidate, report: AggregateReport): boolean {
+    const ctxKey = this.contextKey(candidate.goalHash, report.evaluatorSpecHash);
+    if (!this.buckets.has(ctxKey)) this.buckets.set(ctxKey, new Map());
+    const bucket = this.buckets.get(ctxKey)!;
+
+    const descriptor = sevenDimensionalDescriptor(candidate.genome);
+    const cellKey = this.cellKey(descriptor);
+    const existing = bucket.get(cellKey);
+
+    if (!existing || scoreOf(report) > scoreOf(existing.report)) {
+      bucket.set(cellKey, { candidate, report, descriptor });
+      return true;
+    }
+    return false;
+  }
+
+  getBest(ctxKey: string): ArchiveEntry | null {
+    const bucket = this.buckets.get(ctxKey);
+    if (!bucket || bucket.size === 0) return null;
+    let best: ArchiveEntry | null = null;
+    for (const entry of bucket.values()) {
+      if (!best || scoreOf(entry.report) > scoreOf(best.report)) best = entry;
+    }
+    return best;
+  }
+
+  size(ctxKey: string): number {
+    return this.buckets.get(ctxKey)?.size ?? 0;
+  }
+
+  /** Retains temporarily inferior stepping stones (DGM open-ended branching): returns ALL entries in the context, not only the elite. */
+  allEntries(ctxKey: string): ArchiveEntry[] {
+    return [...(this.buckets.get(ctxKey)?.values() ?? [])];
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 10. Structural-diversity monitor
+// ---------------------------------------------------------------------
+// Motivated by the file's own design rationale: "Structural-diversity
+// monitoring, because repeated LLM mutation can converge into narrow
+// structural attractors." No body was supplied for this in the truncated
+// spec; implemented here as a real, testable metric: mean pairwise
+// Euclidean distance across the 21-dimension genome vectors of an epoch's
+// candidates, flagged narrow if below a fixed threshold.
+// ═══════════════════════════════════════════════════════════════════════
+export interface DiversityReport {
+  meanPairwiseDistance: number;
+  narrowAttractor: boolean;
+  populationSize: number;
+}
+
+const NARROW_ATTRACTOR_THRESHOLD = 0.35;
+
+export function assessStructuralDiversity(genomes: readonly Genome[]): DiversityReport {
+  if (genomes.length < 2) {
+    return { meanPairwiseDistance: 1, narrowAttractor: false, populationSize: genomes.length };
+  }
+
+  const ids = dimensionIds();
+  const vectors = genomes.map((g) => ids.map((id) => g[id] ?? 0));
+
+  let sum = 0;
+  let count = 0;
+  for (let i = 0; i < vectors.length; i++) {
+    for (let j = i + 1; j < vectors.length; j++) {
+      let squared = 0;
+      for (let k = 0; k < ids.length; k++) squared += (vectors[i][k] - vectors[j][k]) ** 2;
+      sum += Math.sqrt(squared);
+      count += 1;
+    }
+  }
+
+  const meanDistance = count > 0 ? sum / count : 0;
+  return {
+    meanPairwiseDistance: Math.round(meanDistance * 10000) / 10000,
+    narrowAttractor: meanDistance < NARROW_ATTRACTOR_THRESHOLD,
+    populationSize: genomes.length,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 11. GEPA-style textual-feedback mutation engine
+// ---------------------------------------------------------------------
+// Design rationale from the file header: "Trajectory feedback and textual
+// diagnostic information, rather than scalar-only optimization, following
+// GEPA." Implemented here as real logic: scans an AggregateReport's
+// `actionableInformation` and `anomalies` strings for keywords naming a V1
+// discovery block (e.g. "evaluator", "anomaly", "taste"), and nudges every
+// dimension in that block toward its high pole using V2's real
+// `applyMutation("nudge", ...)` operator — never a scalar-only step.
+// ═══════════════════════════════════════════════════════════════════════
+const BLOCK_KEYWORDS: Readonly<Record<string, string>> = {
+  "Problem Choice": "problem",
+  "Anomaly Valuation": "anomaly",
+  Embodiment: "world",
+  Analogy: "analog",
+  "Evaluator Revision": "evaluator",
+  Taste: "taste",
+  "Social Stabilization": "social",
+};
+
+export function nudgeGenomeFromFeedback(
+  genome: Genome,
+  report: AggregateReport,
+  parentSeed: number,
+  operationIndex = 0,
+): Genome {
+  const feedbackText = [...report.actionableInformation, ...report.anomalies].join(" ").toLowerCase();
+
+  const targetedBlocks = Object.entries(BLOCK_KEYWORDS)
+    .filter(([, keyword]) => feedbackText.includes(keyword))
+    .map(([block]) => block);
+
+  if (targetedBlocks.length === 0) {
+    return applyMutation(genome, parentSeed, "nudge", operationIndex);
+  }
+
+  let mutated = { ...genome };
+  for (const block of targetedBlocks) {
+    const ids = DIMENSION_BLOCKS[block] ?? [];
+    for (const id of ids) {
+      mutated[id] = clamp01((mutated[id] ?? 0.5) + 0.1);
+    }
+  }
+  return mutated;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 12. Evaluation committee — committee aggregation, quorum, co-evolution
+//     only at epoch boundaries
+// ═══════════════════════════════════════════════════════════════════════
+export interface CommitteePolicyOptions {
+  quorum?: number;
+}
+
+export class CommitteePolicy {
+  readonly quorum: number;
+  constructor(options: CommitteePolicyOptions = {}) {
+    this.quorum = options.quorum ?? 1;
+  }
+}
+
+export class EvaluationCommittee {
+  constructor(
+    public readonly evaluators: readonly CandidateEvaluator[],
+    public readonly policy: CommitteePolicy,
+  ) {}
+
+  get spec(): EvaluatorSpec {
+    return this.evaluators[0].spec;
+  }
+
+  async evaluate(candidate: BlindCandidate, goal: GoalSpec, tools: ToolRegistryLike, budget: BudgetState): Promise<AggregateReport> {
+    const reports: EvaluationReport[] = [];
+    const errors: string[] = [];
+
+    for (const evaluator of this.evaluators) {
+      try {
+        budget.consume("evaluatorCalls", 1);
+        const report = await evaluator.evaluate(candidate, goal, tools);
+        report.validate(candidate.candidateId, evaluator.spec);
+        reports.push(report);
+      } catch (error) {
+        errors.push(`${evaluator.name}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+
+    const spec = this.spec;
+    const metrics: Record<string, number> = {};
+    const metricSpread: Record<string, number> = {};
+
+    for (const metric of spec.metrics) {
+      const values = reports.map((r) => r.metrics[metric]).filter((v) => typeof v === "number");
+      metrics[metric] = values.length ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+      metricSpread[metric] = values.length ? Math.max(...values) - Math.min(...values) : 0;
+    }
+
+    // Hard-gate aggregation rule (this module's own, disclosed): a gate
+    // passes for the committee only if EVERY reporting evaluator marks it
+    // true — evaluator-family separation must not let one lenient evaluator
+    // paper over another's rejection.
+    const hardGates: Record<string, boolean> = {};
+    for (const gate of spec.hardGates) {
+      hardGates[gate] = reports.length > 0 && reports.every((r) => r.hardGates[gate] === true);
+    }
+
+    const confidence = reports.length ? reports.reduce((a, r) => a + r.confidence, 0) / reports.length : 0;
+    const verified = reports.length >= this.policy.quorum && errors.length === 0 && Object.values(hardGates).every(Boolean);
+
+    return new AggregateReport({
+      candidateId: candidate.candidateId,
+      evaluatorSpecHash: spec.contentHash,
+      metrics,
+      metricSpread,
+      hardGates,
+      confidence,
+      evidence: reports.flatMap((r) => r.evidence),
+      actionableInformation: reports.flatMap((r) => r.actionableInformation),
+      anomalies: reports.flatMap((r) => r.anomalies),
+      evaluatorIds: reports.map((r) => r.evaluatorId),
+      errors,
+      verified,
+      reports,
+    });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 13. Discovery engine — "High-horizon orchestrator enforcing the
+//     Hashimoto-Fowler Harness Thesis" (docstring survived; body did not).
+//     Implemented in full below as the described P/A/E/N/V/T/S-scheduled,
+//     goal-versioned, budget-accounted, tamper-evident-logged epoch runner.
+// ═══════════════════════════════════════════════════════════════════════
+export interface DiscoveryEngineInit {
+  runId: string;
+  seed: number;
+  domain: string;
+  goal: GoalSpec;
+  producers: readonly CandidateProducer[];
+  committee: EvaluationCommittee;
+  tools: ToolRegistryLike;
+  store: EventStore;
+  budget: BudgetState;
+  risk?: RiskTier;
+}
+
+export class DiscoveryEngine {
+  readonly runId: string;
+  readonly seed: number;
+  readonly domain: string;
+  goal: GoalSpec;
+  readonly producers: readonly CandidateProducer[];
+  readonly committee: EvaluationCommittee;
+  readonly tools: ToolRegistryLike;
+  readonly store: EventStore;
+  readonly budget: BudgetState;
+  readonly risk: RiskTier;
+  readonly archive = new VersionedArchive();
+  readonly memory: MemoryLedger;
+
+  private epochTrace: Array<Record<string, unknown>> = [];
+
+  constructor(init: DiscoveryEngineInit) {
+    this.runId = init.runId;
+    this.seed = init.seed;
+    this.domain = init.domain;
+    this.goal = init.goal;
+    this.producers = init.producers;
+    this.committee = init.committee;
+    this.tools = init.tools;
+    this.store = init.store;
+    this.budget = init.budget;
+    this.risk = init.risk ?? "medium";
+    this.memory = new MemoryLedger(this.store, this.runId);
+
+    this.goal.validate();
+    this.store.createRun(this.runId, this.seed, this.domain, this.risk, {
+      goal_hash: this.goal.contentHash,
+      evaluator_spec_hash: this.committee.spec.contentHash,
+    });
+  }
+
+  /** Runs one epoch: generates n candidates, evaluates each through the committee, updates the versioned archive, and enforces budget + safety gates throughout. Mirrors the Python CLI's `engine.run_epoch(epoch=1, n_candidates=2)`. */
+  async runEpoch(epoch: number, nCandidates: number): Promise<Array<{ candidate: Candidate; report: AggregateReport }>> {
+    if (nCandidates < 1) throw new Error("nCandidates must be >= 1");
+
+    const domainPack: DomainPack = DOMAIN_PACKS[this.domain] ?? DOMAIN_PACKS.general;
+    const safetyGate = new SafetyGate(this.risk, domainPack);
+
+    const results: Array<{ candidate: Candidate; report: AggregateReport }> = [];
+    const epochGenomes: Genome[] = [];
+
+    for (let index = 0; index < nCandidates; index++) {
+      this.budget.consume("candidates", 1);
+
+      const candidateSeed = deriveSeed(this.runId, epoch, index, this.seed);
+      let genome = seedToGenome(candidateSeed);
+      genome = safetyGate.transformGenome(genome);
+      epochGenomes.push(genome);
+
+      const persona = classifyPersonaExtended(genome);
+      const path = selectPathExtended(genome);
+      const schedule = new GraphLifeScheduler(candidateSeed, genome, path.id).build();
+
+      const promptBase = compileInnovationPrompt(genome, persona, path, this.goal.statement, this.domain);
+      const prompt = promptBase + safetyGate.promptAddendum();
+
+      const request: GenerationRequest = {
+        runId: this.runId,
+        epoch,
+        candidateIndex: index,
+        candidateSeed,
+        goal: this.goal,
+        evaluatorSpec: this.committee.spec,
+        genome,
+        persona,
+        path,
+        schedule,
+        prompt,
+      };
+
+      this.store.appendEvent(this.runId, "candidate_requested", {
+        epoch,
+        candidate_index: index,
+        candidate_seed: candidateSeed,
+        persona: persona.name,
+        path: path.id,
+      });
+
+      const producer = this.producers[index % this.producers.length];
+      const artifact = await producer.produce(request, this.tools);
+      const artifactHash = sha256Text(artifact);
+      const candidateId = sha256Text(canonicalJson({ runId: this.runId, epoch, index, artifactHash })).slice(0, 24);
+
+      const candidate = new Candidate(
+        candidateId,
+        this.runId,
+        epoch,
+        index,
+        candidateSeed,
+        this.goal.contentHash,
+        this.committee.spec.contentHash,
+        genome,
+        persona,
+        path,
+        schedule,
+        artifact,
+        producer.name,
+        producer.family,
+        [],
+        "initial generation",
+        artifactHash,
+      );
+
+      this.store.appendEvent(this.runId, "candidate_generated", { candidate_id: candidateId, artifact_hash: artifactHash });
+
+      const report = await this.committee.evaluate(candidate.blind(), this.goal, this.tools, this.budget);
+
+      this.store.appendEvent(this.runId, "candidate_evaluated", {
+        candidate_id: candidateId,
+        verified: report.verified,
+        metrics: report.metrics,
+      });
+
+      this.archive.add(candidate, report);
+      results.push({ candidate, report });
+    }
+
+    const diversity = assessStructuralDiversity(epochGenomes);
+    this.store.appendEvent(this.runId, "epoch_completed", {
+      epoch,
+      n_candidates: nCandidates,
+      mean_pairwise_distance: diversity.meanPairwiseDistance,
+      narrow_attractor: diversity.narrowAttractor,
+    });
+
+    this.epochTrace.push({
+      epoch,
+      n_candidates: nCandidates,
+      results: results.map((r) => ({ candidate_id: r.candidate.candidateId, verified: r.report.verified })),
+      diversity,
+    });
+
+    return results;
+  }
+
+  getEpochTrace(): readonly Record<string, unknown>[] {
+    return this.epochTrace;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 14. Final verifiable receipt — port of `generate_v3_report`
+// ═══════════════════════════════════════════════════════════════════════
+export interface V3Report {
+  sys: { version: string; status: string };
+  run_id: string;
+  goal: Record<string, unknown>;
+  evaluator_spec: Record<string, unknown>;
+  budget: Record<string, unknown>;
+  archive_size: number;
+  tamper_evident_seal: boolean;
+  best_candidate?: {
+    id: string;
+    metrics: Record<string, number>;
+    verified: boolean;
+    artifact_preview: string;
+  };
+}
+
+export function generateV3Report(engine: DiscoveryEngine): V3Report {
+  const ctxKey = `${engine.goal.contentHash}:${engine.committee.spec.contentHash}`;
+  const bestEntry = engine.archive.getBest(ctxKey);
+
+  const report: V3Report = {
+    sys: { version: "v3.1-OMEGA", status: "TERMINAL_SATURATION" },
+    run_id: engine.runId,
+    goal: {
+      version: engine.goal.version,
+      statement: engine.goal.statement,
+      success_criteria: engine.goal.successCriteria,
+      hard_constraints: engine.goal.hardConstraints,
+      soft_objectives: engine.goal.softObjectives,
+      parent_hash: engine.goal.parentHash,
+      rationale: engine.goal.rationale,
+      approvals: engine.goal.approvals,
+    },
+    evaluator_spec: {
+      version: engine.committee.spec.version,
+      metrics: engine.committee.spec.metrics,
+      hard_gates: engine.committee.spec.hardGates,
+      parent_hash: engine.committee.spec.parentHash,
+      rationale: engine.committee.spec.rationale,
+    },
+    budget: engine.budget.toDict(),
+    archive_size: engine.archive.size(ctxKey),
+    tamper_evident_seal: engine.store.verifyChain(engine.runId),
+  };
+
+  if (bestEntry) {
+    report.best_candidate = {
+      id: bestEntry.candidate.candidateId,
+      metrics: bestEntry.report.metrics,
+      verified: bestEntry.report.verified,
+      artifact_preview: `${bestEntry.candidate.artifact.slice(0, 200)}...`,
+    };
+  }
+
+  return report;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 15. CLI equivalent — port of `main()`. There is no argparse/stdout in a
+//     browser; this exported async function performs EXACTLY the same
+//     construction sequence and returns the same report `main()` prints.
+// ═══════════════════════════════════════════════════════════════════════
+export interface V3DemoOptions {
+  problem: string;
+  domain?: string;
+  seed?: number;
+}
+
+export async function runInnovationGenomeV3Demo(options: V3DemoOptions): Promise<V3Report> {
+  const domain = options.domain ?? "mathematics";
+  const seed = options.seed ?? Math.floor(Date.now() / 1000);
+
+  const goal = new GoalSpec({
+    version: 1,
+    statement: options.problem,
+    successCriteria: ["Proof survives committee audit"],
+    hardConstraints: ["Exact constants must be re-derived"],
+  });
+
+  const spec = new EvaluatorSpec({ version: 1 });
+
+  const producer = new FunctionProducer("BaseLLM", "GPT", (request) => `Solved ${request.goal.statement} via ${request.path.id}`);
+
+  const evaluator = new FunctionEvaluator("StaticAudit", "Audit", spec, (candidate) =>
+    new EvaluationReport({
+      candidateId: candidate.candidateId,
+      evaluatorId: "StaticAudit",
+      evaluatorFamily: "Audit",
+      evaluatorSpecHash: spec.contentHash,
+      metrics: Object.fromEntries(spec.metrics.map((m) => [m, 0.8])),
+      hardGates: Object.fromEntries(spec.hardGates.map((g) => [g, true])),
+      confidence: 0.9,
+      evidence: ["Evidence A"],
+    }),
+  );
+
+  const store = new EventStore();
+  const budget = new BudgetState(new BudgetLimits());
+  const registry = new ToolRegistry(new CapabilityGate(), budget);
+  const committee = new EvaluationCommittee([evaluator], new CommitteePolicy({ quorum: 1 }));
+
+  const runId = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : sha256Text(String(Math.random()));
+
+  const engine = new DiscoveryEngine({
+    runId,
+    seed,
+    domain,
+    goal,
+    producers: [producer],
+    committee,
+    tools: registry,
+    store,
+    budget,
+  });
+
+  await engine.runEpoch(1, 2);
+
+  return generateV3Report(engine);
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// 16. Diagnostics — the original test_innovation_genome_v3.py content was
+//     never supplied in the task prompt (only its filename appeared in the
+//     file tree), so it could not be ported. This suite independently
+//     verifies every contract that IS legible in the spec, plus the SHA-256
+//     implementation against the two published NIST test vectors.
+// ═══════════════════════════════════════════════════════════════════════
+export interface DiagnosticCheck {
+  id: string;
+  passed: boolean;
+  detail: string;
+}
+
+export async function runInnovationGenomeV3Diagnostics(): Promise<{ ok: boolean; checks: DiagnosticCheck[] }> {
+  const checks: DiagnosticCheck[] = [];
+  const add = (id: string, passed: boolean, detail: string) => checks.push({ id, passed, detail });
+
+  // SHA-256 against NIST test vectors (real cryptographic verification, no network needed).
+  add("sha256-empty-string", sha256Text("") === "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "FIPS 180-4 vector");
+  add("sha256-abc", sha256Text("abc") === "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "FIPS 180-4 vector");
+
+  // Genome validation.
+  const genome = seedToGenome(42);
+  try { validateGenome(genome); add("validate-genome-ok", true, "no throw on valid genome"); }
+  catch { add("validate-genome-ok", false, "unexpected throw"); }
+
+  try {
+    validateGenome({ ...genome, extra_dim: 0.5 });
+    add("validate-genome-rejects-extra", false, "did not throw");
+  } catch (e) {
+    add("validate-genome-rejects-extra", e instanceof Error && e.message.includes("unknown dimensions"), String(e));
+  }
+
+  // GoalSpec / EvaluatorSpec hashing determinism + validation.
+  const goal = new GoalSpec({ version: 1, statement: "Prove X", successCriteria: ["c1"], hardConstraints: ["h1"] });
+  const goal2 = new GoalSpec({ version: 1, statement: "Prove X", successCriteria: ["c1"], hardConstraints: ["h1"] });
+  add("goal-hash-deterministic", goal.contentHash === goal2.contentHash, goal.contentHash);
+  try { new GoalSpec({ version: 0, statement: "x", successCriteria: ["c"], hardConstraints: ["h"] }).validate(); add("goal-rejects-version-0", false, "no throw"); }
+  catch { add("goal-rejects-version-0", true, "threw as expected"); }
+
+  const spec = new EvaluatorSpec({ version: 1 });
+  try { spec.validate(); add("evaluator-spec-valid", true, "no throw"); }
+  catch { add("evaluator-spec-valid", false, "unexpected throw"); }
+
+  // GraphLifeScheduler determinism + primary-path coverage guarantee.
+  const scheduler1 = new GraphLifeScheduler(42, genome, "α");
+  const scheduler2 = new GraphLifeScheduler(42, genome, "α");
+  const waves1 = scheduler1.build();
+  const waves2 = scheduler2.build();
+  add("graph-life-deterministic", JSON.stringify(waves1.map((w) => w.toDict())) === JSON.stringify(waves2.map((w) => w.toDict())), `waves=${waves1.length}`);
+
+  const visitedNodes = new Set(waves1.flatMap((w) => w.nodes));
+  const coversPrimary = PATH_NODES["α"].every((n) => visitedNodes.has(n));
+  add("graph-life-covers-primary-path", coversPrimary, `visited=${[...visitedNodes].join(",")}`);
+
+  // GoalMutationPolicy.
+  const policy = new GoalMutationPolicy();
+  const proposedGoal = new GoalSpec({
+    version: 2,
+    statement: "Prove X, extended",
+    successCriteria: ["c1"],
+    hardConstraints: ["h1"],
+    parentHash: goal.contentHash,
+    rationale: "extend scope",
+    approvals: ["reviewer:alice"],
+  });
+  const errors = policy.validate(goal, proposedGoal, true);
+  add("goal-mutation-policy-accepts-valid", errors.length === 0, JSON.stringify(errors));
+
+  const badProposedGoal = new GoalSpec({
+    version: 2,
+    statement: "Prove X, extended",
+    successCriteria: ["c1"],
+    hardConstraints: [], // removed the hard constraint
+    parentHash: goal.contentHash,
+    rationale: "extend scope",
+    approvals: ["reviewer:alice"],
+  });
+  const errors2 = policy.validate(goal, badProposedGoal, true);
+  add("goal-mutation-policy-rejects-constraint-removal", errors2.some((e) => e.includes("hard constraint") || e.includes("must contain")), JSON.stringify(errors2));
+
+  // Budget accounting.
+  const budget = new BudgetState(new BudgetLimits({ candidates: 2 }));
+  budget.consume("candidates", 2);
+  let budgetThrew = false;
+  try { budget.consume("candidates", 1); } catch (e) { budgetThrew = e instanceof BudgetExceeded; }
+  add("budget-exceeded-throws", budgetThrew, "BudgetExceeded raised at limit");
+
+  // EventStore hash chain.
+  const store = new EventStore();
+  store.createRun("test-run", 1, "general", "low", {});
+  store.appendEvent("test-run", "custom_event", { a: 1 });
+  store.appendEvent("test-run", "custom_event", { a: 2 });
+  add("event-store-chain-verifies", store.verifyChain("test-run"), "3 events (run_created + 2 custom)");
+
+  // Checkpoint round-trip.
+  const stateHash = store.saveCheckpoint("test-run", "cp1", { value: 42 });
+  const loaded = store.loadCheckpoint("test-run", "cp1");
+  add("checkpoint-roundtrip", (loaded as { value: number }).value === 42 && typeof stateHash === "string", stateHash);
+
+  // MemoryLedger.
+  const memory = new MemoryLedger(store, "test-run");
+  const memId = memory.add("insight", { text: "found a pattern" }, 0.8);
+  add("memory-open-lists", memory.listOpen().some((m) => m.memory_id === memId), memId);
+  memory.resolve(memId, { outcome: "confirmed" });
+  add("memory-resolved-removed-from-open", !memory.listOpen().some((m) => m.memory_id === memId), "resolved");
+
+  // Calibration.
+  const calibrationEvaluator = new FunctionEvaluator("Cal", "CalFam", spec, (candidate) =>
+    new EvaluationReport({
+      candidateId: candidate.candidateId,
+      evaluatorId: "Cal",
+      evaluatorFamily: "CalFam",
+      evaluatorSpecHash: spec.contentHash,
+      metrics: Object.fromEntries(spec.metrics.map((m) => [m, 0.5])),
+      hardGates: Object.fromEntries(spec.hardGates.map((g) => [g, true])),
+      confidence: 0.7,
+      evidence: [],
+    }),
+  );
+  const dummyTools: ToolRegistryLike = { callTool: async () => ({ stdout: "", stderr: "", exitCode: 0 }) };
+  const calibrationScore = await calibrateEvaluator(
+    calibrationEvaluator,
+    [{ artifact: "artifact-1", expectedHardGates: { correctness: true } }],
+    goal,
+    dummyTools,
+  );
+  add("calibration-score-in-range", calibrationScore >= 0 && calibrationScore <= 1, String(calibrationScore));
+
+  // Versioned archive invariant: different goal hash must not share a bucket.
+  const archive = new VersionedArchive();
+  const dummyReport = new AggregateReport({
+    candidateId: "c1",
+    evaluatorSpecHash: spec.contentHash,
+    metrics: { novelty: 0.5, utility: 0.5, tractability: 0.5, robustness: 0.5, taste: 0.5 },
+    metricSpread: {},
+    hardGates: { correctness: true, scope: true, evidence: true, safety: true },
+    confidence: 0.8,
+    evidence: [],
+    actionableInformation: [],
+    anomalies: [],
+    evaluatorIds: ["e1"],
+    errors: [],
+    verified: true,
+    reports: [],
+  });
+  const dummyCandidate = new Candidate(
+    "c1", "run1", 1, 0, 1, goal.contentHash, spec.contentHash, genome,
+    { name: "P", tagline: "t" }, { id: "α", name: "n", seq: "s" }, [],
+    "artifact text", "prod", "fam", [], "initial", sha256Text("artifact text"),
+  );
+  archive.add(dummyCandidate, dummyReport);
+  const ctxA = `${goal.contentHash}:${spec.contentHash}`;
+  const ctxB = `${proposedGoal.contentHash}:${spec.contentHash}`;
+  add("archive-versioning-invariant", archive.size(ctxA) === 1 && archive.size(ctxB) === 0, `sizeA=${archive.size(ctxA)} sizeB=${archive.size(ctxB)}`);
+
+  // Structural diversity monitor.
+  const identicalGenomes = [genome, genome, genome];
+  const diverse = assessStructuralDiversity(identicalGenomes);
+  add("diversity-detects-narrow-attractor", diverse.narrowAttractor === true, JSON.stringify(diverse));
+
+  // Full end-to-end demo run (mirrors the CLI main()).
+  const demoReport = await runInnovationGenomeV3Demo({ problem: "Prove X.", domain: "mathematics", seed: 42 });
+  add("demo-report-sealed", demoReport.tamper_evident_seal === true, "hash chain verified end-to-end");
+  add("demo-report-has-best-candidate", demoReport.best_candidate !== undefined, JSON.stringify(demoReport.best_candidate ?? null));
+
+  return { ok: checks.every((c) => c.passed), checks };
+}