@metaharness/darwin 0.1.0

package/dist/archive.js

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+//
+// The archive (ADR-073) — Darwin Mode's population memory. The archive is a
+// TREE of variants, persisted as `archive.json`, not a single best branch.
+// Non-promoted variants are RETAINED, not deleted: "did not clear the promotion
+// gate" means "not chosen as a parent by the default policy", never "removed".
+// Selection (`selectParents`) samples the WHOLE archive — including older,
+// non-promoted branches — which is how evolution escapes hill-climbing.
+//
+// Dependency-free (Node built-ins only). The on-disk shape is a stable
+// `ArchiveRecord[]` so that load → save → load round-trips exactly.
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+/**
+ * In-memory tree of {@link ArchiveRecord}s keyed by variant id, persisted to a
+ * JSON file. Insertion order is preserved (a `Map` iterates in insertion order)
+ * so every ordering — `all`, tie-breaks in `best`, ties in `selectParents` — is
+ * deterministic and reproducible from `archive.json` alone.
+ */
+export class Archive {
+    file;
+    /** variantId → record. A Map preserves insertion order. */
+    records = new Map();
+    /**
+     * @param file Absolute path to `archive.json`. The file need not exist yet;
+     *   {@link load} tolerates a missing or corrupt file by starting empty.
+     */
+    constructor(file) {
+        this.file = file;
+    }
+    /**
+     * Load records from {@link file} if it exists. A missing, unreadable, or
+     * corrupt file (or one whose JSON is not an `ArchiveRecord[]`) is tolerated by
+     * starting from an empty archive — never throws.
+     */
+    async load() {
+        this.records.clear();
+        let raw;
+        try {
+            raw = await readFile(this.file, 'utf8');
+        }
+        catch {
+            return; // missing / unreadable — start empty
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return; // corrupt JSON — start empty
+        }
+        if (!Array.isArray(parsed))
+            return; // wrong shape — start empty
+        for (const entry of parsed) {
+            if (!isArchiveRecord(entry))
+                continue; // skip malformed entries defensively
+            this.records.set(entry.variant.id, entry);
+        }
+    }
+    /**
+     * Insert a record `{ variant, score: null, children: [] }` if the variant id
+     * is absent (idempotent — a re-add is a no-op). When `variant.parentId` is set
+     * and that parent already exists, append this id to the parent's `children`
+     * (without duplicates), wiring up the tree edge.
+     */
+    addVariant(variant) {
+        if (this.records.has(variant.id))
+            return; // idempotent
+        this.records.set(variant.id, { variant, score: null, children: [] });
+        const parentId = variant.parentId;
+        if (parentId !== null) {
+            const parent = this.records.get(parentId);
+            if (parent && !parent.children.includes(variant.id)) {
+                parent.children.push(variant.id);
+            }
+        }
+    }
+    /**
+     * Attach a scorecard to a variant. Throws a clear error if the variant id is
+     * unknown — scoring a phantom variant is a programmer error, not a soft miss.
+     */
+    setScore(variantId, score) {
+        const record = this.records.get(variantId);
+        if (!record) {
+            throw new Error(`Archive.setScore: unknown variant "${variantId}" (add it before scoring)`);
+        }
+        record.score = score;
+    }
+    /** The record for `variantId`, or `undefined` if it is not in the archive. */
+    get(variantId) {
+        return this.records.get(variantId);
+    }
+    /** Every record, in insertion order. */
+    all() {
+        return [...this.records.values()];
+    }
+    /**
+     * The scored record with the highest `score.finalScore`, or `null` when no
+     * record is scored yet. Ties break toward the earlier insertion (the first
+     * record to reach that score wins), making the choice deterministic.
+     */
+    best() {
+        let winner = null;
+        for (const record of this.records.values()) {
+            if (record.score === null)
+                continue;
+            if (winner === null || record.score.finalScore > winner.score.finalScore) {
+                winner = record;
+            }
+        }
+        return winner;
+    }
+    /**
+     * The archive-wide selection that escapes hill-climbing: the top-`limit`
+     * scored variants by `finalScore`, drawn from the WHOLE archive including
+     * older, non-promoted branches (ADR-073 stall fallback). Deterministic — ties
+     * break by insertion order, so the result is reproducible.
+     *
+     * @param limit Maximum number of parents to return. `<= 0` yields `[]`.
+     */
+    selectParents(limit) {
+        if (limit <= 0)
+            return [];
+        // Tag with insertion index so ties break deterministically by insertion order.
+        const scored = [];
+        let index = 0;
+        for (const record of this.records.values()) {
+            if (record.score !== null)
+                scored.push({ record, index });
+            index += 1;
+        }
+        scored.sort((a, b) => {
+            const delta = b.record.score.finalScore - a.record.score.finalScore;
+            if (delta !== 0)
+                return delta; // higher finalScore first
+            return a.index - b.index; // tie-break: earlier insertion first
+        });
+        return scored.slice(0, limit).map((s) => s.record.variant);
+    }
+    /**
+     * The path of ids from the root ancestor down to `variantId`, following
+     * `parentId` upward then reversing. Returns `[]` if `variantId` is unknown.
+     * Guarded against cycles (e.g. a self-parent or a corrupt ancestor loop): each
+     * id is visited at most once, so the walk always terminates.
+     */
+    lineageOf(variantId) {
+        if (!this.records.has(variantId))
+            return [];
+        const path = [];
+        const seen = new Set();
+        let currentId = variantId;
+        while (currentId !== null && !seen.has(currentId)) {
+            const record = this.records.get(currentId);
+            if (!record)
+                break; // dangling parent reference — stop the climb
+            seen.add(currentId);
+            path.push(currentId);
+            currentId = record.variant.parentId;
+        }
+        return path.reverse(); // root ancestor first, target last
+    }
+    /**
+     * A serializable projection of the tree for rendering the evolution graph:
+     * one node per record (carrying generation, mutated surface, final score, and
+     * promotion flag), and one edge per existing parent→child relationship. Edges
+     * referencing a missing endpoint are omitted so the graph stays well-formed.
+     */
+    toLineageGraph() {
+        const nodes = [];
+        const edges = [];
+        for (const record of this.records.values()) {
+            const { variant, score } = record;
+            nodes.push({
+                id: variant.id,
+                parentId: variant.parentId,
+                generation: variant.generation,
+                mutationSurface: variant.mutationSurface,
+                finalScore: score === null ? null : score.finalScore,
+                promoted: score === null ? null : score.promoted,
+            });
+            for (const childId of record.children) {
+                if (this.records.has(childId)) {
+                    edges.push({ from: variant.id, to: childId });
+                }
+            }
+        }
+        return { nodes, edges };
+    }
+    /**
+     * Persist the archive as pretty-printed JSON to {@link file}, creating the
+     * parent directory if needed. The on-disk shape is exactly `all()` — an
+     * `ArchiveRecord[]` in insertion order — so a subsequent {@link load}
+     * reconstructs the same archive.
+     */
+    async save() {
+        await mkdir(dirname(this.file), { recursive: true });
+        const json = JSON.stringify(this.all(), null, 2);
+        await writeFile(this.file, `${json}\n`, 'utf8');
+    }
+}
+/**
+ * Structural guard for a single on-disk record. Defensive against hand-edited or
+ * partially-written `archive.json` files: only entries with the minimal shape
+ * (a variant with an id, plus a `children` array) are admitted.
+ */
+function isArchiveRecord(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const obj = value;
+    const variant = obj.variant;
+    if (variant === null || typeof variant !== 'object')
+        return false;
+    if (typeof variant.id !== 'string')
+        return false;
+    if (!Array.isArray(obj.children))
+        return false;
+    // score may be null or a ScoreCard object; both are acceptable here.
+    return true;
+}
+//# sourceMappingURL=archive.js.map

package/dist/archive.js.map

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

package/dist/bench/gates.d.ts

@@ -0,0 +1,19 @@
+import type { BenchmarkResult, BenchmarkTask, GateResult } from './types.js';
+/** Solve gate: the public AND hidden acceptance tests both pass. */
+export declare function solveGate(r: BenchmarkResult): GateResult;
+/** Regression gate: the full relevant suite still passes. */
+export declare function regressionGate(r: BenchmarkResult): GateResult;
+/** Safety gate: zero blocked-file touches and zero safety violations (ADR-071). */
+export declare function safetyGate(r: BenchmarkResult): GateResult;
+/** Cost gate: the metered cost is within the task's budget. */
+export declare function costGate(r: BenchmarkResult, task: BenchmarkTask): GateResult;
+/** Repro gate: a clean checkout reproduced the result. */
+export declare function reproGate(cleanReplay: boolean): GateResult;
+/**
+ * Evaluate all five gates in canonical order: solve, regression, safety, cost,
+ * repro. Returns one GateResult per gate.
+ */
+export declare function evaluateGates(r: BenchmarkResult, task: BenchmarkTask, cleanReplay: boolean): GateResult[];
+/** True iff every gate in the list passed. */
+export declare function allGatesPass(gates: GateResult[]): boolean;
+//# sourceMappingURL=gates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gates.d.ts","sourceRoot":"","sources":["../../src/bench/gates.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,oEAAoE;AACpE,wBAAgB,SAAS,CAAC,CAAC,EAAE,eAAe,GAAG,UAAU,CASxD;AAED,6DAA6D;AAC7D,wBAAgB,cAAc,CAAC,CAAC,EAAE,eAAe,GAAG,UAAU,CAS7D;AAED,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,CAAC,EAAE,eAAe,GAAG,UAAU,CAWzD;AAED,+DAA+D;AAC/D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,aAAa,GAAG,UAAU,CAS5E;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,WAAW,EAAE,OAAO,GAAG,UAAU,CAQ1D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,eAAe,EAClB,IAAI,EAAE,aAAa,EACnB,WAAW,EAAE,OAAO,GACnB,UAAU,EAAE,CAQd;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,OAAO,CAEzD"}

package/dist/bench/gates.js

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: MIT
+//
+// The five evaluation gates (ADR-076). A child wins a task only when it clears
+// all five: solve (public ∧ hidden), regression, safety (zero blocked-file
+// touches / safety violations), cost (within the task budget), and repro (a
+// clean checkout reproduces the result).
+//
+// Each gate is a pure predicate over a BenchmarkResult (+ task budget / replay
+// flag) returning a GateResult with a short human-readable verdict. No I/O.
+/** Solve gate: the public AND hidden acceptance tests both pass. */
+export function solveGate(r) {
+    const pass = r.publicTestPassed && r.hiddenTestPassed;
+    return {
+        gate: 'solve',
+        pass,
+        detail: pass
+            ? 'solved: public and hidden tests passed'
+            : `not solved: public=${r.publicTestPassed}, hidden=${r.hiddenTestPassed}`,
+    };
+}
+/** Regression gate: the full relevant suite still passes. */
+export function regressionGate(r) {
+    const pass = r.regressionPassed;
+    return {
+        gate: 'regression',
+        pass,
+        detail: pass
+            ? 'no regression: full suite passed'
+            : 'regression: full suite failed',
+    };
+}
+/** Safety gate: zero blocked-file touches and zero safety violations (ADR-071). */
+export function safetyGate(r) {
+    const pass = r.safetyViolations.length === 0 && r.blockedFileTouches.length === 0;
+    return {
+        gate: 'safety',
+        pass,
+        detail: pass
+            ? 'safe: no safety violations or blocked-file touches'
+            : `unsafe: ${r.safetyViolations.length} violation(s), ` +
+                `${r.blockedFileTouches.length} blocked-file touch(es)`,
+    };
+}
+/** Cost gate: the metered cost is within the task's budget. */
+export function costGate(r, task) {
+    const pass = r.costUsd <= task.maxCostUsd;
+    return {
+        gate: 'cost',
+        pass,
+        detail: pass
+            ? `within budget: $${r.costUsd} <= $${task.maxCostUsd}`
+            : `over budget: $${r.costUsd} > $${task.maxCostUsd}`,
+    };
+}
+/** Repro gate: a clean checkout reproduced the result. */
+export function reproGate(cleanReplay) {
+    return {
+        gate: 'repro',
+        pass: cleanReplay,
+        detail: cleanReplay
+            ? 'reproducible: clean replay matched'
+            : 'not reproducible: clean replay mismatched',
+    };
+}
+/**
+ * Evaluate all five gates in canonical order: solve, regression, safety, cost,
+ * repro. Returns one GateResult per gate.
+ */
+export function evaluateGates(r, task, cleanReplay) {
+    return [
+        solveGate(r),
+        regressionGate(r),
+        safetyGate(r),
+        costGate(r, task),
+        reproGate(cleanReplay),
+    ];
+}
+/** True iff every gate in the list passed. */
+export function allGatesPass(gates) {
+    return gates.every((g) => g.pass);
+}
+//# sourceMappingURL=gates.js.map

package/dist/bench/gates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gates.js","sourceRoot":"","sources":["../../src/bench/gates.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,+EAA+E;AAC/E,2EAA2E;AAC3E,4EAA4E;AAC5E,yCAAyC;AACzC,EAAE;AACF,+EAA+E;AAC/E,4EAA4E;AAQ5E,oEAAoE;AACpE,MAAM,UAAU,SAAS,CAAC,CAAkB;IAC1C,MAAM,IAAI,GAAG,CAAC,CAAC,gBAAgB,IAAI,CAAC,CAAC,gBAAgB,CAAC;IACtD,OAAO;QACL,IAAI,EAAE,OAAO;QACb,IAAI;QACJ,MAAM,EAAE,IAAI;YACV,CAAC,CAAC,wCAAwC;YAC1C,CAAC,CAAC,sBAAsB,CAAC,CAAC,gBAAgB,YAAY,CAAC,CAAC,gBAAgB,EAAE;KAC7E,CAAC;AACJ,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,cAAc,CAAC,CAAkB;IAC/C,MAAM,IAAI,GAAG,CAAC,CAAC,gBAAgB,CAAC;IAChC,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,IAAI;QACJ,MAAM,EAAE,IAAI;YACV,CAAC,CAAC,kCAAkC;YACpC,CAAC,CAAC,+BAA+B;KACpC,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,UAAU,CAAC,CAAkB;IAC3C,MAAM,IAAI,GACR,CAAC,CAAC,gBAAgB,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,CAAC;IACvE,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,IAAI;QACJ,MAAM,EAAE,IAAI;YACV,CAAC,CAAC,oDAAoD;YACtD,CAAC,CAAC,WAAW,CAAC,CAAC,gBAAgB,CAAC,MAAM,iBAAiB;gBACrD,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,yBAAyB;KAC5D,CAAC;AACJ,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,QAAQ,CAAC,CAAkB,EAAE,IAAmB;IAC9D,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC;IAC1C,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,IAAI;QACJ,MAAM,EAAE,IAAI;YACV,CAAC,CAAC,mBAAmB,CAAC,CAAC,OAAO,QAAQ,IAAI,CAAC,UAAU,EAAE;YACvD,CAAC,CAAC,iBAAiB,CAAC,CAAC,OAAO,OAAO,IAAI,CAAC,UAAU,EAAE;KACvD,CAAC;AACJ,CAAC;AAED,0DAA0D;AAC1D,MAAM,UAAU,SAAS,CAAC,WAAoB;IAC5C,OAAO;QACL,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,WAAW;QACjB,MAAM,EAAE,WAAW;YACjB,CAAC,CAAC,oCAAoC;YACtC,CAAC,CAAC,2CAA2C;KAChD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAC3B,CAAkB,EAClB,IAAmB,EACnB,WAAoB;IAEpB,OAAO;QACL,SAAS,CAAC,CAAC,CAAC;QACZ,cAAc,CAAC,CAAC,CAAC;QACjB,UAAU,CAAC,CAAC,CAAC;QACb,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC;QACjB,SAAS,CAAC,WAAW,CAAC;KACvB,CAAC;AACJ,CAAC;AAED,8CAA8C;AAC9C,MAAM,UAAU,YAAY,CAAC,KAAmB;IAC9C,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AACpC,CAAC"}

package/dist/bench/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './score.js';
+export * from './gates.js';
+export * from './stats.js';
+export * from './promotion.js';
+export * from './risk.js';
+export * from './metrics.js';
+export * from './lineage.js';
+export * from './suite.js';
+export * from './runner.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bench/index.ts"],"names":[],"mappings":"AAeA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/bench/index.js

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+//
+// @metaharness/darwin — benchmark layer (ADR-076 + the SOTA "Darwin Plus" stack,
+// ADR-077…081). Benchmark the parent vs the child, not the idea.
+//
+//   types      — the benchmark contract (tasks, results, suites, decisions)
+//   score      — the verified-solve score + penalty layer (ADR-076)
+//   gates      — the five gates: solve · regression · safety · cost · repro
+//   stats      — the SEEDED bootstrap confidence (reproducible, unlike Math.random)
+//   promotion  — the statistical promotion rule (ADR-076)
+//   risk       — the SGM extended gate + global cumulative risk budget (ADR-079)
+//   lineage    — descendant potential + clade parent selection (HGM, ADR-078)
+//   suite      — immutable, hash-pinned task snapshots (anti-tampering)
+//   runner     — the parent-vs-child evaluation over the secure sandbox
+export * from './types.js';
+export * from './score.js';
+export * from './gates.js';
+export * from './stats.js';
+export * from './promotion.js';
+export * from './risk.js';
+export * from './metrics.js';
+export * from './lineage.js';
+export * from './suite.js';
+export * from './runner.js';
+//# sourceMappingURL=index.js.map

package/dist/bench/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bench/index.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,iFAAiF;AACjF,iEAAiE;AACjE,EAAE;AACF,4EAA4E;AAC5E,oEAAoE;AACpE,4EAA4E;AAC5E,oFAAoF;AACpF,0DAA0D;AAC1D,iFAAiF;AACjF,8EAA8E;AAC9E,wEAAwE;AACxE,wEAAwE;AAExE,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/bench/lineage.d.ts

@@ -0,0 +1,60 @@
+import type { LineageNode } from './types.js';
+/**
+ * Descendant potential: how much better this node's BEST descendants are than
+ * the node itself. We take the top-`topK` descendants by score, average them,
+ * and return `avgTop - node.score` (can be negative when descendants regressed).
+ * A leaf — or a node whose entire sub-tree is empty — has potential 0.
+ *
+ * This is the core "best branch beats best agent" signal: a low-scoring node
+ * that already produced high-scoring children gets a large positive lift.
+ *
+ * @param nodeId the node to evaluate.
+ * @param nodes the full lineage keyed by id.
+ * @param topK how many of the best descendants to average (default 3).
+ * @returns rounded `avgTopK(descendantScores) - node.score`, or 0 if no
+ *   descendants (or the node is absent).
+ */
+export declare function descendantPotential(nodeId: string, nodes: Map<string, LineageNode>, topK?: number): number;
+/**
+ * Archive diversity: a structural novelty score in [0,1] that rewards
+ * UNDER-explored branches. Defined as `1 / (1 + siblingCount)`, where
+ * `siblingCount` is the number of OTHER children of this node's parent. A node
+ * with no siblings (or a root, or a node whose parent is absent from the map)
+ * scores 1; the more crowded its branch, the lower the score (3 siblings ⇒ 1/4).
+ *
+ * @param nodeId the node to evaluate.
+ * @param nodes the full lineage keyed by id.
+ * @returns rounded novelty score in (0,1].
+ */
+export declare function archiveDiversity(nodeId: string, nodes: Map<string, LineageNode>): number;
+/** Relative weights for the three parent-selection signals. */
+export interface SelectionWeights {
+    score?: number;
+    potential?: number;
+    diversity?: number;
+}
+/**
+ * Combined parent-selection score for one node: a weighted blend of its own
+ * score, its descendant potential, and its archive diversity. With the default
+ * weights a fertile low-scoring branch can out-rank a sterile high-scoring leaf.
+ *
+ * @param nodeId the node to evaluate.
+ * @param nodes the full lineage keyed by id.
+ * @param weights optional overrides for the three signal weights.
+ * @param topK forwarded to {@link descendantPotential}.
+ * @returns rounded selection score, or 0 if the node is absent.
+ */
+export declare function parentSelectionScore(nodeId: string, nodes: Map<string, LineageNode>, weights?: SelectionWeights, topK?: number): number;
+/**
+ * Rank ALL node ids by {@link parentSelectionScore} (descending) and return the
+ * top `limit`. Tie-break is DETERMINISTIC by id ascending, so the result is
+ * stable across runs. A non-positive `limit` yields an empty list.
+ *
+ * @param nodes the full lineage keyed by id.
+ * @param limit how many parents to return.
+ * @param weights optional overrides forwarded to {@link parentSelectionScore}.
+ * @param topK optional, forwarded to {@link descendantPotential}.
+ * @returns the top-`limit` node ids, best first.
+ */
+export declare function selectParentsByPotential(nodes: Map<string, LineageNode>, limit: number, weights?: SelectionWeights, topK?: number): string[];
+//# sourceMappingURL=lineage.d.ts.map

package/dist/bench/lineage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage.d.ts","sourceRoot":"","sources":["../../src/bench/lineage.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA6C9C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAC/B,IAAI,SAAI,GACP,MAAM,CAqBR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAC9B,MAAM,CAYR;AAED,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAC/B,OAAO,CAAC,EAAE,gBAAgB,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CAWR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAC/B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,gBAAgB,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,EAAE,CAWV"}

package/dist/bench/lineage.js

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: MIT
+//
+// Lineage selection (ADR-076, §"Descendant-potential-aware selection") — pick
+// the next parents to mutate by the PROMISE OF THE BRANCH, not just the score of
+// the node. A low-scoring node that already spawned high-scoring descendants is
+// a fertile lineage worth re-exploring; a high-scoring leaf with no offspring is
+// a dead end. We blend three signals: the node's own score, the lift its best
+// descendants show over it (descendant potential), and a structural novelty
+// bonus for under-explored branches (archive diversity).
+//
+// Pure functions, no I/O. Every public number is rounded to 6 decimals
+// (ADR-075 reproducibility clause) so re-running on the same map yields a
+// byte-identical, deterministic result. Tie-breaks are by id so ranking is
+// stable across runs. Dependency-free (Node built-ins only).
+/**
+ * Round to 6 decimal places. Kills float-representation noise so values are
+ * byte-identical across runs. The leading `+` drops any `-0`. Re-implemented
+ * locally to keep this module dependency-free.
+ */
+function round6(value) {
+    return +(Math.round(value * 1e6) / 1e6).toFixed(6);
+}
+/**
+ * Collect ALL descendant ids of `nodeId` via iterative depth-first search over
+ * `children`. CYCLE-GUARDED: a `visited` set ensures a malformed tree (e.g. a
+ * cycle, or a node listed twice as a child) can never infinite-loop. The start
+ * node itself is not included in the result.
+ *
+ * @param nodeId the root of the sub-tree to enumerate.
+ * @param nodes the full lineage keyed by id.
+ * @returns the set of reachable descendant ids (excluding `nodeId`).
+ */
+function collectDescendants(nodeId, nodes) {
+    const found = new Set();
+    const visited = new Set([nodeId]);
+    const start = nodes.get(nodeId);
+    if (!start)
+        return found;
+    const stack = [...start.children];
+    while (stack.length > 0) {
+        const id = stack.pop();
+        if (visited.has(id))
+            continue; // cycle / re-visit guard
+        visited.add(id);
+        const node = nodes.get(id);
+        if (!node)
+            continue; // dangling child reference — skip
+        found.add(id);
+        for (const child of node.children) {
+            if (!visited.has(child))
+                stack.push(child);
+        }
+    }
+    return found;
+}
+/**
+ * Descendant potential: how much better this node's BEST descendants are than
+ * the node itself. We take the top-`topK` descendants by score, average them,
+ * and return `avgTop - node.score` (can be negative when descendants regressed).
+ * A leaf — or a node whose entire sub-tree is empty — has potential 0.
+ *
+ * This is the core "best branch beats best agent" signal: a low-scoring node
+ * that already produced high-scoring children gets a large positive lift.
+ *
+ * @param nodeId the node to evaluate.
+ * @param nodes the full lineage keyed by id.
+ * @param topK how many of the best descendants to average (default 3).
+ * @returns rounded `avgTopK(descendantScores) - node.score`, or 0 if no
+ *   descendants (or the node is absent).
+ */
+export function descendantPotential(nodeId, nodes, topK = 3) {
+    const node = nodes.get(nodeId);
+    if (!node)
+        return 0;
+    const descendants = collectDescendants(nodeId, nodes);
+    if (descendants.size === 0)
+        return 0;
+    const scores = [];
+    for (const id of descendants) {
+        const d = nodes.get(id);
+        if (d)
+            scores.push(d.score);
+    }
+    if (scores.length === 0)
+        return 0;
+    const k = Math.max(1, Math.min(topK, scores.length));
+    scores.sort((a, b) => b - a);
+    let sum = 0;
+    for (let i = 0; i < k; i += 1)
+        sum += scores[i];
+    const avgTop = sum / k;
+    return round6(avgTop - node.score);
+}
+/**
+ * Archive diversity: a structural novelty score in [0,1] that rewards
+ * UNDER-explored branches. Defined as `1 / (1 + siblingCount)`, where
+ * `siblingCount` is the number of OTHER children of this node's parent. A node
+ * with no siblings (or a root, or a node whose parent is absent from the map)
+ * scores 1; the more crowded its branch, the lower the score (3 siblings ⇒ 1/4).
+ *
+ * @param nodeId the node to evaluate.
+ * @param nodes the full lineage keyed by id.
+ * @returns rounded novelty score in (0,1].
+ */
+export function archiveDiversity(nodeId, nodes) {
+    const node = nodes.get(nodeId);
+    if (!node)
+        return 1;
+    // Root, or an orphan whose parent is not in the map: maximally novel.
+    if (node.parentId == null)
+        return 1;
+    const parent = nodes.get(node.parentId);
+    if (!parent)
+        return 1;
+    // OTHER children of the parent (exclude this node itself, once).
+    const siblingCount = parent.children.filter((c) => c !== nodeId).length;
+    return round6(1 / (1 + siblingCount));
+}
+/** ADR-076 default blend: score dominates, but branch promise and novelty count. */
+const DEFAULT_WEIGHTS = {
+    score: 0.7,
+    potential: 0.2,
+    diversity: 0.1,
+};
+/**
+ * Combined parent-selection score for one node: a weighted blend of its own
+ * score, its descendant potential, and its archive diversity. With the default
+ * weights a fertile low-scoring branch can out-rank a sterile high-scoring leaf.
+ *
+ * @param nodeId the node to evaluate.
+ * @param nodes the full lineage keyed by id.
+ * @param weights optional overrides for the three signal weights.
+ * @param topK forwarded to {@link descendantPotential}.
+ * @returns rounded selection score, or 0 if the node is absent.
+ */
+export function parentSelectionScore(nodeId, nodes, weights, topK) {
+    const node = nodes.get(nodeId);
+    if (!node)
+        return 0;
+    const w = { ...DEFAULT_WEIGHTS, ...weights };
+    const potential = descendantPotential(nodeId, nodes, topK);
+    const diversity = archiveDiversity(nodeId, nodes);
+    return round6(w.score * node.score + w.potential * potential + w.diversity * diversity);
+}
+/**
+ * Rank ALL node ids by {@link parentSelectionScore} (descending) and return the
+ * top `limit`. Tie-break is DETERMINISTIC by id ascending, so the result is
+ * stable across runs. A non-positive `limit` yields an empty list.
+ *
+ * @param nodes the full lineage keyed by id.
+ * @param limit how many parents to return.
+ * @param weights optional overrides forwarded to {@link parentSelectionScore}.
+ * @param topK optional, forwarded to {@link descendantPotential}.
+ * @returns the top-`limit` node ids, best first.
+ */
+export function selectParentsByPotential(nodes, limit, weights, topK) {
+    if (limit <= 0)
+        return [];
+    const scored = [...nodes.keys()].map((id) => ({
+        id,
+        score: parentSelectionScore(id, nodes, weights, topK),
+    }));
+    scored.sort((a, b) => (b.score - a.score) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return scored.slice(0, limit).map((s) => s.id);
+}
+//# sourceMappingURL=lineage.js.map

package/dist/bench/lineage.js.map

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