@evomap/evolver-core 2.0.0-beta.0

package/dist/assetstore/provider.js

@@ -0,0 +1,36 @@
+import { computeAssetId, verifyAssetId } from '../wire/index.js';
+export class AssetIdMismatchError extends Error {
+    claimed;
+    actual;
+    constructor(claimed, actual) {
+        super(`asset_id 不自洽: 声明 ${claimed} 实算 ${actual}`);
+        this.claimed = claimed;
+        this.actual = actual;
+        this.name = 'AssetIdMismatchError';
+    }
+}
+export class CapsuleGeneBindingError extends Error {
+    constructor() { super('Capsule.gene 必须非空或显式 "ad-hoc" 哨兵 (批注#28/M3-4)'); this.name = 'CapsuleGeneBindingError'; }
+}
+/**
+ * 落库前规范化(共享给各 provider): 计算/校验 asset_id + 强绑定校验.
+ * - 缺 asset_id → 计算填入(verified=false 表示非入参自带).
+ * - 带 asset_id → 必须自洽, 否则抛 AssetIdMismatchError.
+ * - Capsule.gene 必须非空(M3-4 强绑定).
+ */
+export function normalizeForPut(asset) {
+    if (asset.type === 'Capsule') {
+        const gene = asset.gene;
+        if (typeof gene !== 'string' || gene.length === 0)
+            throw new CapsuleGeneBindingError();
+    }
+    const actual = computeAssetId(asset);
+    if (actual === null)
+        throw new Error('computeAssetId 失败: 资产非对象');
+    const claimed = typeof asset.asset_id === 'string' && asset.asset_id.length > 0 && asset.asset_id !== 'IGNORED'
+        ? asset.asset_id : undefined;
+    if (claimed !== undefined && claimed !== actual)
+        throw new AssetIdMismatchError(claimed, actual);
+    const record = { ...asset, asset_id: actual };
+    return { record, verified: claimed !== undefined && verifyAssetId(record) };
+}

package/dist/assetstore/remoteStub.d.ts

@@ -0,0 +1,32 @@
+import { type AssetKind, type AssetRecord, type AssetStoreProvider, type PutResult, type SearchQuery } from './provider.js';
+/** 远程后端传输(M6 换真 hub Capability; M3-1 用内存桩). */
+export interface RemoteTransport {
+    putRemote(record: AssetRecord): Promise<{
+        stored: boolean;
+    }>;
+    getRemote(assetId: string): Promise<AssetRecord | null>;
+    searchRemote(query: SearchQuery): Promise<AssetRecord[]>;
+    listRemote(kind: AssetKind | undefined, limit: number): Promise<AssetRecord[]>;
+}
+/**
+ * 远程资产库参考实现(M3-1). 与 LocalJsonlProvider 同接口, 证明 wire protocol provider-无关.
+ * 落库前同样走 normalizeForPut(asset_id 命门 + 强绑定校验在 core 侧, 不信任远端).
+ */
+export declare class RemoteStubProvider implements AssetStoreProvider {
+    private readonly transport;
+    constructor(transport: RemoteTransport);
+    put(asset: AssetRecord): Promise<PutResult>;
+    get(assetId: string): Promise<AssetRecord | null>;
+    search(query: SearchQuery): Promise<AssetRecord[]>;
+    list(kind?: AssetKind, limit?: number): Promise<AssetRecord[]>;
+}
+/** 内存传输桩(测试/本地演示用). */
+export declare class InMemoryTransport implements RemoteTransport {
+    private readonly db;
+    putRemote(record: AssetRecord): Promise<{
+        stored: boolean;
+    }>;
+    getRemote(assetId: string): Promise<AssetRecord | null>;
+    searchRemote(q: SearchQuery): Promise<AssetRecord[]>;
+    listRemote(kind: AssetKind | undefined, limit: number): Promise<AssetRecord[]>;
+}

package/dist/assetstore/remoteStub.js

@@ -0,0 +1,36 @@
+import { normalizeForPut, } from './provider.js';
+/**
+ * 远程资产库参考实现(M3-1). 与 LocalJsonlProvider 同接口, 证明 wire protocol provider-无关.
+ * 落库前同样走 normalizeForPut(asset_id 命门 + 强绑定校验在 core 侧, 不信任远端).
+ */
+export class RemoteStubProvider {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async put(asset) {
+        const { record, verified } = normalizeForPut(asset);
+        const { stored } = await this.transport.putRemote(record);
+        return { asset_id: record.asset_id, stored, verified };
+    }
+    get(assetId) { return this.transport.getRemote(assetId); }
+    search(query) { return this.transport.searchRemote(query); }
+    list(kind, limit = 1000) { return this.transport.listRemote(kind, limit); }
+}
+/** 内存传输桩(测试/本地演示用). */
+export class InMemoryTransport {
+    db = new Map();
+    async putRemote(record) {
+        if (this.db.has(record.asset_id))
+            return { stored: false };
+        this.db.set(record.asset_id, record);
+        return { stored: true };
+    }
+    async getRemote(assetId) { return this.db.get(assetId) ?? null; }
+    async searchRemote(q) {
+        return [...this.db.values()].filter((r) => !q.kind || r.type === q.kind).slice(0, q.limit ?? 1000);
+    }
+    async listRemote(kind, limit) {
+        return [...this.db.values()].filter((r) => !kind || r.type === kind).slice(0, limit);
+    }
+}

package/dist/assetstore/reviewFilter.d.ts

@@ -0,0 +1,20 @@
+import type { AssetStoreProvider, AssetRecord } from './provider.js';
+import { ReviewLedger } from './reviewLedger.js';
+import { ProvenanceStore } from './provenance.js';
+/**
+ * The ReviewLedger CO-LOCATED with a store — its quarantine/approve records live in the SAME dir as the genes.
+ * A read site that defaults the ledger independently (e.g. always `assetsDir()`) would, when handed an injected
+ * store at a different dir, consult the WRONG ledger and let a draft quarantined beside that store leak.
+ * `LocalJsonlProvider.baseDir` is public exactly so callers can co-locate sidecars; any other provider falls back
+ * to the live assets dir.
+ */
+export declare function reviewLedgerForStore(store: AssetStoreProvider): ReviewLedger;
+/** The ProvenanceStore CO-LOCATED with a store, symmetric to reviewLedgerForStore. */
+export declare function provenanceStoreForStore(store: AssetStoreProvider): ProvenanceStore;
+/**
+ * Read up to `maxGenes` trusted-origin and REVIEW-APPROVED genes from the store, preserving store order.
+ * Default-eligible: a gene with NO review record passes (local / cycle / migrated genes); only an explicitly
+ * quarantined or rejected draft is withheld. A gene with NO provenance record is trusted; hub-ingested genes are
+ * withheld until promotion. This mirrors candidateAssembly's trust-first + review-first filters.
+ */
+export declare function listApprovedGenes(store: AssetStoreProvider, review: ReviewLedger, maxGenes: number, provenance?: ProvenanceStore): Promise<AssetRecord[]>;

package/dist/assetstore/reviewFilter.js

@@ -0,0 +1,44 @@
+import { LocalJsonlProvider } from './localJsonl.js';
+import { ReviewLedger } from './reviewLedger.js';
+import { ProvenanceStore } from './provenance.js';
+import { assetsDir } from '../events/paths.js';
+// Scan window before review filtering — the local gene pool is bounded; mirrors makeTrustedGeneResolver's
+// `list('Gene', 1000)`. Scanning wider than maxGenes then filtering means a quarantined draft sitting in the
+// top-N can never crowd an approved gene out of the result (filter-then-bound, not bound-then-filter).
+const GENE_SCAN_LIMIT = 1000;
+/**
+ * The ReviewLedger CO-LOCATED with a store — its quarantine/approve records live in the SAME dir as the genes.
+ * A read site that defaults the ledger independently (e.g. always `assetsDir()`) would, when handed an injected
+ * store at a different dir, consult the WRONG ledger and let a draft quarantined beside that store leak.
+ * `LocalJsonlProvider.baseDir` is public exactly so callers can co-locate sidecars; any other provider falls back
+ * to the live assets dir.
+ */
+export function reviewLedgerForStore(store) {
+    const baseDir = store instanceof LocalJsonlProvider ? store.baseDir : assetsDir();
+    return new ReviewLedger(baseDir);
+}
+/** The ProvenanceStore CO-LOCATED with a store, symmetric to reviewLedgerForStore. */
+export function provenanceStoreForStore(store) {
+    const baseDir = store instanceof LocalJsonlProvider ? store.baseDir : assetsDir();
+    return new ProvenanceStore(baseDir);
+}
+/**
+ * Read up to `maxGenes` trusted-origin and REVIEW-APPROVED genes from the store, preserving store order.
+ * Default-eligible: a gene with NO review record passes (local / cycle / migrated genes); only an explicitly
+ * quarantined or rejected draft is withheld. A gene with NO provenance record is trusted; hub-ingested genes are
+ * withheld until promotion. This mirrors candidateAssembly's trust-first + review-first filters.
+ */
+export async function listApprovedGenes(store, review, maxGenes, provenance = provenanceStoreForStore(store)) {
+    const all = await store.list('Gene', GENE_SCAN_LIMIT);
+    const approved = [];
+    for (const g of all) {
+        if (!provenance.isTrusted(String(g.asset_id)))
+            continue; // hub-untrusted → withhold until promoted
+        if (!review.isApproved(String(g.asset_id)))
+            continue; // quarantined/rejected draft → withhold
+        approved.push(g);
+        if (approved.length >= maxGenes)
+            break;
+    }
+    return approved;
+}

package/dist/assetstore/reviewLedger.d.ts

@@ -0,0 +1,55 @@
+export type ReviewState = 'quarantined' | 'approved' | 'rejected';
+export interface ReviewRecord {
+    assetId: string;
+    state: ReviewState;
+    at: string;
+    by?: string;
+    reason?: string;
+}
+/**
+ * Append-only JSONL sidecar at <baseDir>/review.jsonl. Default for an asset with NO record = approved (eligible):
+ * only auto-distilled drafts are quarantined here; everything else is eligible by default.
+ *
+ * Resolution is precedence-based, NOT pure last-write-wins: a HUMAN decision (approved/rejected) always beats an
+ * auto `quarantined` record regardless of append order; later beats earlier only WITHIN the same class. This is
+ * the race guard — `ingest --distill` (quarantine) and `evolver review --approve` (human) run as separate
+ * processes, so a quarantine line appended AFTER an approval must not silently withhold the approved gene.
+ */
+export declare class ReviewLedger {
+    private readonly now;
+    private readonly path;
+    private readonly index;
+    private sig;
+    constructor(baseDir: string, now?: () => number);
+    private static isHuman;
+    /** Which record wins for an asset_id: a human decision beats a quarantine; otherwise the later one wins. */
+    private static keep;
+    private load;
+    /** Record a review-state for an asset_id (append-only; the JSONL history is the audit trail). */
+    mark(rec: Omit<ReviewRecord, 'at'> & {
+        at?: string;
+    }): ReviewRecord;
+    /** Quarantine an auto-distilled draft: its strategy must not enter a real run until reviewed. */
+    quarantine(assetId: string, reason?: string): ReviewRecord;
+    /**
+     * Quarantine ONLY if the asset has no record yet — the atomic, reload-aware form `ingest --distill` uses so a
+     * re-distill never re-quarantines a gene a human already approved/rejected. The check + append happen here as
+     * one operation (reloads first to see any external decision), closing the caller-side get→quarantine gap; and
+     * because `keep()` lets a human decision win regardless of order, a quarantine that still races in behind an
+     * approval is inert. Returns the surviving record (the existing decision, or the new quarantine).
+     */
+    quarantineIfAbsent(assetId: string, reason?: string): ReviewRecord;
+    /** Explicit, audited approval (who/why) — flips a draft to eligible. */
+    approve(assetId: string, by: string, reason: string): ReviewRecord;
+    /** Explicit, audited rejection (who/why) — a reviewed terminal state that stays out of runs. */
+    reject(assetId: string, by: string, reason: string): ReviewRecord;
+    get(assetId: string): ReviewRecord | null;
+    /**
+     * Every recorded review decision (resolved, reload-aware). The authoritative source of which assets are
+     * quarantined/approved/rejected — a queue/UI must read pending state from HERE, not by scanning a truncated
+     * asset list, so a draft awaiting approval is never missed behind a store-list cutoff.
+     */
+    records(): ReviewRecord[];
+    /** No record → approved (default eligible); a record → approved only when its state is 'approved'. */
+    isApproved(assetId: string): boolean;
+}

package/dist/assetstore/reviewLedger.js

@@ -0,0 +1,121 @@
+// Review-state gate: `ingest --distill` mints UNPROVEN gene drafts from real sessions. Their CONTENT quality is
+// unvetted (auto-extracted transcript excerpts), so — like a hub-ingested asset under provenance (#30) — a draft
+// must not influence a real autonomous run until a human reviews it. Review-state is a SIDECAR keyed by asset_id,
+// NOT a field on the asset: asset_id = sha256(canonicalize(asset)), and "has a human vetted this" metadata must
+// not enter the content hash, or it would break content-addressing. Symmetric to provenance, but a DIFFERENT
+// axis: provenance = trustworthy origin (anti-poisoning); review-state = vetted draft quality. The embed gate
+// (#45 requireTrustedGene) only injects a gene's strategy when it is BOTH trusted-origin AND review-approved.
+//
+// Default (no record) = approved/eligible: the only writer of quarantine records is `--distill`; cycle-self-
+// produced and v1-migrated genes are never quarantined, so the explore→prove loop is untouched for them.
+import { appendFileSync, existsSync, readFileSync, mkdirSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+/**
+ * Append-only JSONL sidecar at <baseDir>/review.jsonl. Default for an asset with NO record = approved (eligible):
+ * only auto-distilled drafts are quarantined here; everything else is eligible by default.
+ *
+ * Resolution is precedence-based, NOT pure last-write-wins: a HUMAN decision (approved/rejected) always beats an
+ * auto `quarantined` record regardless of append order; later beats earlier only WITHIN the same class. This is
+ * the race guard — `ingest --distill` (quarantine) and `evolver review --approve` (human) run as separate
+ * processes, so a quarantine line appended AFTER an approval must not silently withhold the approved gene.
+ */
+export class ReviewLedger {
+    now;
+    path;
+    index = new Map();
+    sig = ''; // `${mtimeMs}:${size}` of review.jsonl at the last index build; '' = never loaded / file absent
+    constructor(baseDir, now = Date.now) {
+        this.now = now;
+        this.path = join(baseDir, 'review.jsonl');
+    }
+    static isHuman(s) { return s === 'approved' || s === 'rejected'; }
+    /** Which record wins for an asset_id: a human decision beats a quarantine; otherwise the later one wins. */
+    static keep(existing, r) {
+        if (!existing)
+            return r;
+        if (ReviewLedger.isHuman(r.state))
+            return r; // human decision always wins (and later human beats earlier)
+        return ReviewLedger.isHuman(existing.state) ? existing : r; // a quarantine replaces only a prior quarantine
+    }
+    // Reload-aware (not load-once): the resident `autoexec` daemon holds ONE ReviewLedger, yet an operator runs
+    // `evolver review --approve` in a SEPARATE process. Re-read review.jsonl whenever its mtime+size changed, so a
+    // live approval lifts a quarantined gene without restarting the daemon. The file is small and queried at most
+    // once per cycle, so a statSync per query is cheap. (mtime alone can collide within one ms → pair it with size.)
+    load() {
+        if (!existsSync(this.path)) {
+            this.index.clear();
+            this.sig = '';
+            return;
+        }
+        const st = statSync(this.path);
+        const sig = `${st.mtimeMs}:${st.size}`;
+        if (sig === this.sig)
+            return; // unchanged since last read → cached index is current
+        this.index.clear();
+        for (const line of readFileSync(this.path, 'utf8').split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const r = JSON.parse(line);
+                if (r.assetId)
+                    this.index.set(r.assetId, ReviewLedger.keep(this.index.get(r.assetId), r));
+            }
+            catch { /* skip corrupt line */ }
+        }
+        this.sig = sig;
+    }
+    /** Record a review-state for an asset_id (append-only; the JSONL history is the audit trail). */
+    mark(rec) {
+        this.load();
+        const full = { ...rec, at: rec.at ?? new Date(this.now()).toISOString() };
+        mkdirSync(dirname(this.path), { recursive: true });
+        appendFileSync(this.path, `${JSON.stringify(full)}\n`);
+        this.index.set(full.assetId, ReviewLedger.keep(this.index.get(full.assetId), full));
+        const st = statSync(this.path); // single stat: two separate calls could straddle a concurrent same-ms append
+        this.sig = `${st.mtimeMs}:${st.size}`; // our own write is already indexed; don't force a re-read
+        return full;
+    }
+    /** Quarantine an auto-distilled draft: its strategy must not enter a real run until reviewed. */
+    quarantine(assetId, reason = 'auto-distilled — review before use') {
+        return this.mark({ assetId, state: 'quarantined', reason });
+    }
+    /**
+     * Quarantine ONLY if the asset has no record yet — the atomic, reload-aware form `ingest --distill` uses so a
+     * re-distill never re-quarantines a gene a human already approved/rejected. The check + append happen here as
+     * one operation (reloads first to see any external decision), closing the caller-side get→quarantine gap; and
+     * because `keep()` lets a human decision win regardless of order, a quarantine that still races in behind an
+     * approval is inert. Returns the surviving record (the existing decision, or the new quarantine).
+     */
+    quarantineIfAbsent(assetId, reason = 'auto-distilled — review before use') {
+        this.load();
+        const existing = this.index.get(assetId);
+        return existing ?? this.quarantine(assetId, reason);
+    }
+    /** Explicit, audited approval (who/why) — flips a draft to eligible. */
+    approve(assetId, by, reason) {
+        return this.mark({ assetId, state: 'approved', by, reason });
+    }
+    /** Explicit, audited rejection (who/why) — a reviewed terminal state that stays out of runs. */
+    reject(assetId, by, reason) {
+        return this.mark({ assetId, state: 'rejected', by, reason });
+    }
+    get(assetId) {
+        this.load();
+        return this.index.get(assetId) ?? null;
+    }
+    /**
+     * Every recorded review decision (resolved, reload-aware). The authoritative source of which assets are
+     * quarantined/approved/rejected — a queue/UI must read pending state from HERE, not by scanning a truncated
+     * asset list, so a draft awaiting approval is never missed behind a store-list cutoff.
+     */
+    records() {
+        this.load();
+        return [...this.index.values()];
+    }
+    /** No record → approved (default eligible); a record → approved only when its state is 'approved'. */
+    isApproved(assetId) {
+        this.load();
+        const r = this.index.get(assetId);
+        return r ? r.state === 'approved' : true;
+    }
+}

package/dist/benchmark/antiGeneBenchmark.d.ts

@@ -0,0 +1,79 @@
+import type { AssetStoreProvider } from '../assetstore/provider.js';
+import { ReviewLedger } from '../assetstore/reviewLedger.js';
+import type { ReportEvent } from '../events/reports.js';
+import type { GepCategory } from '../wire/index.js';
+export type AntiGeneBenchmarkArm = 'baseline' | 'antiGene';
+export type AntiGeneBenchmarkVerdict = 'anti_gene_better' | 'no_clear_improvement' | 'anti_gene_worse' | 'insufficient_samples';
+export interface AntiGeneBenchmarkOutcomeSpec {
+    status: 'success' | 'failed';
+    repeatedFailure?: boolean;
+    overblocked?: boolean;
+    score?: number;
+    reason?: string;
+}
+export interface AntiGeneBenchmarkTask {
+    id: string;
+    signals: string[];
+    target?: string;
+    expectedEffect?: string;
+    category?: GepCategory;
+    summary?: string;
+    confidence?: number;
+    expectedAntiWarnings?: string[];
+    outcomes: {
+        baseline: AntiGeneBenchmarkOutcomeSpec;
+        antiGene: AntiGeneBenchmarkOutcomeSpec;
+    };
+}
+export interface AntiGeneBenchmarkSuite {
+    name: string;
+    tasks: AntiGeneBenchmarkTask[];
+}
+export interface AntiGeneBenchmarkArmMetrics {
+    arm: AntiGeneBenchmarkArm;
+    n: number;
+    failures: number;
+    failureRate: number;
+    repeatedFailures: number;
+    overblocked: number;
+    observedWarnings: number;
+}
+export interface AntiGeneBenchmarkTaskResult {
+    taskId: string;
+    baseline: AntiGeneBenchmarkRunResult;
+    antiGene: AntiGeneBenchmarkRunResult;
+}
+export interface AntiGeneBenchmarkRunResult {
+    status: 'success' | 'failed';
+    score: number;
+    repeatedFailure: boolean;
+    overblocked: boolean;
+    observedAntiWarnings: string[];
+    missingExpectedWarnings: string[];
+}
+export interface AntiGeneBenchmarkReport {
+    suite: string;
+    tasks: number;
+    baseline: AntiGeneBenchmarkArmMetrics;
+    antiGene: AntiGeneBenchmarkArmMetrics;
+    missingExpectedWarnings: number;
+    overblocked: number;
+    failureDelta: number;
+    verdict: AntiGeneBenchmarkVerdict;
+    taskResults: AntiGeneBenchmarkTaskResult[];
+    taskResultsTruncated?: number;
+}
+export interface AntiGeneBenchmarkOptions {
+    minSamples?: number;
+    minFailureDelta?: number;
+    now?: () => number;
+    eventsPath?: string;
+}
+export interface AntiGeneBenchmarkDeps {
+    store: AssetStoreProvider;
+    review?: ReviewLedger;
+}
+export declare function runAntiGeneBenchmark(suite: AntiGeneBenchmarkSuite, deps: AntiGeneBenchmarkDeps, options?: AntiGeneBenchmarkOptions): Promise<AntiGeneBenchmarkReport>;
+export declare function writeAntiGeneBenchmarkResult(report: AntiGeneBenchmarkReport, eventsPath: string, now?: () => number): Promise<void>;
+export declare function antiGeneBenchmarkReportsFromEvents(events: readonly ReportEvent[]): AntiGeneBenchmarkReport[];
+export declare function latestAntiGeneBenchmarkReport(events: readonly ReportEvent[]): AntiGeneBenchmarkReport | null;

package/dist/benchmark/antiGeneBenchmark.js

@@ -0,0 +1,241 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { LocalJsonlProvider } from '../assetstore/localJsonl.js';
+import { ReviewLedger } from '../assetstore/reviewLedger.js';
+import { Ingestor } from '../events/ingest.js';
+import { LineTooLargeError } from '../events/eventStore.js';
+import { CycleEngine } from '../algo/cycleEngine.js';
+import { runEvolutionCycle } from '../algo/orchestrator.js';
+import { makeGeneSelectionPoint } from '../algo/geneSelection.js';
+const ALL_ASSETS_LIMIT = Number.MAX_SAFE_INTEGER;
+const ASSET_KINDS = ['Gene', 'Capsule', 'EvolutionEvent', 'AntiGene'];
+function buildProblem(task, now) {
+    return {
+        id: task.id,
+        signature: `anti-gene-benchmark:${task.id}`,
+        signatureV: 1,
+        firstSeenAt: new Date(now - 1000).toISOString(),
+        lastSeenAt: new Date(now).toISOString(),
+        occurrences: 3,
+        linkedSignals: task.signals,
+        resolvedBy: null,
+        status: 'open',
+        value: { severity: 1, reach: 1, strategicFit: 1, novelty: 0, costEst: 0 },
+        consecutiveFailures: 0,
+        cooldownUntil: null,
+        extensions: {},
+    };
+}
+async function copyAssets(source, dest, includeAntiGenes) {
+    for (const kind of ASSET_KINDS) {
+        if (kind === 'AntiGene' && !includeAntiGenes)
+            continue;
+        for (const asset of await source.list(kind, ALL_ASSETS_LIMIT))
+            await dest.put(asset);
+    }
+}
+function copyReview(source, dest) {
+    for (const record of source?.records() ?? []) {
+        dest.mark({
+            assetId: record.assetId,
+            state: record.state,
+            ...(record.by ? { by: record.by } : {}),
+            ...(record.reason ? { reason: record.reason } : {}),
+            at: record.at,
+        });
+    }
+}
+function defaultReviewForStore(store, now) {
+    const baseDir = store.baseDir;
+    return typeof baseDir === 'string' ? new ReviewLedger(baseDir, now) : null;
+}
+function observedWarningIds(decision) {
+    if (!decision || typeof decision !== 'object')
+        return [];
+    const warnings = decision.antiWarnings;
+    if (!Array.isArray(warnings))
+        return [];
+    return warnings
+        .map((warning) => {
+        if (!warning || typeof warning !== 'object' || Array.isArray(warning))
+            return '';
+        const row = warning;
+        return String(row.antiGeneId ?? row.assetId ?? '');
+    })
+        .filter(Boolean);
+}
+function missingExpected(expected, observed) {
+    const seen = new Set(observed);
+    return (expected ?? []).filter((id) => !seen.has(id));
+}
+function executeFor(outcome) {
+    return () => ({
+        outcome: {
+            status: outcome.status,
+            score: outcome.score ?? (outcome.status === 'success' ? 0.9 : 0.2),
+            ...(outcome.reason ? { reason: outcome.reason } : {}),
+        },
+    });
+}
+async function runOneArm(arm, task, source, sourceReview, rootDir, now) {
+    const armDir = join(rootDir, arm, task.id);
+    const store = new LocalJsonlProvider(join(armDir, 'assets'));
+    const review = new ReviewLedger(join(armDir, 'assets'), now);
+    await copyAssets(source, store, arm === 'antiGene');
+    copyReview(sourceReview, review);
+    const eventPath = join(armDir, 'events.jsonl');
+    const engine = new CycleEngine({
+        ingestor: new Ingestor({ path: eventPath, now }),
+        selection: makeGeneSelectionPoint(),
+        store,
+        now,
+    });
+    const spec = task.outcomes[arm];
+    const opts = {
+        cycleId: `${arm}-${task.id}`,
+        problem: buildProblem(task, now()),
+        signals: task.signals,
+        category: task.category ?? 'repair',
+        target: task.target ?? 't.ts',
+        expectedEffect: task.expectedEffect ?? `anti-gene benchmark ${task.id}`,
+        summary: task.summary ?? `anti-gene benchmark ${task.id}`,
+        confidence: task.confidence ?? 0.9,
+        execute: executeFor(spec),
+        review,
+        consumePendingSignals: false,
+    };
+    const result = await runEvolutionCycle(engine, store, opts);
+    const observed = observedWarningIds(result.decision);
+    return {
+        status: spec.status,
+        score: spec.score ?? (spec.status === 'success' ? 0.9 : 0.2),
+        repeatedFailure: spec.repeatedFailure === true,
+        overblocked: spec.overblocked === true,
+        observedAntiWarnings: observed,
+        missingExpectedWarnings: arm === 'antiGene' ? missingExpected(task.expectedAntiWarnings, observed) : [],
+    };
+}
+function armMetrics(arm, results) {
+    const n = results.length;
+    const failures = results.filter((r) => r.status === 'failed').length;
+    return {
+        arm,
+        n,
+        failures,
+        failureRate: n > 0 ? failures / n : 0,
+        repeatedFailures: results.filter((r) => r.repeatedFailure).length,
+        overblocked: results.filter((r) => r.overblocked).length,
+        observedWarnings: results.reduce((sum, r) => sum + r.observedAntiWarnings.length, 0),
+    };
+}
+function verdict(report, minSamples, minFailureDelta) {
+    if (report.baseline.n < minSamples || report.antiGene.n < minSamples)
+        return 'insufficient_samples';
+    if (report.failureDelta >= minFailureDelta && report.antiGene.observedWarnings > 0 && report.missingExpectedWarnings === 0)
+        return 'anti_gene_better';
+    if (report.failureDelta < -minFailureDelta || (minFailureDelta === 0 && report.failureDelta < 0))
+        return 'anti_gene_worse';
+    return 'no_clear_improvement';
+}
+function buildReport(suite, taskResults, minSamples, minFailureDelta) {
+    const baseline = armMetrics('baseline', taskResults.map((r) => r.baseline));
+    const antiGene = armMetrics('antiGene', taskResults.map((r) => r.antiGene));
+    const partial = {
+        suite: suite.name,
+        tasks: suite.tasks.length,
+        baseline,
+        antiGene,
+        missingExpectedWarnings: taskResults.reduce((sum, r) => sum + r.antiGene.missingExpectedWarnings.length, 0),
+        overblocked: antiGene.overblocked,
+        failureDelta: baseline.failureRate - antiGene.failureRate,
+        taskResults,
+    };
+    return { ...partial, verdict: verdict(partial, minSamples, minFailureDelta) };
+}
+export async function runAntiGeneBenchmark(suite, deps, options = {}) {
+    const now = options.now ?? Date.now;
+    const sourceReview = deps.review ?? defaultReviewForStore(deps.store, now);
+    if (!sourceReview)
+        throw new Error('AntiGene benchmark requires a ReviewLedger or a LocalJsonlProvider-backed store so review state can be copied');
+    const minSamples = options.minSamples ?? 30;
+    const minFailureDelta = options.minFailureDelta ?? 0.05;
+    const rootDir = mkdtempSync(join(tmpdir(), 'anti-gene-benchmark-'));
+    try {
+        const taskResults = [];
+        for (const task of suite.tasks) {
+            taskResults.push({
+                taskId: task.id,
+                baseline: await runOneArm('baseline', task, deps.store, sourceReview, rootDir, now),
+                antiGene: await runOneArm('antiGene', task, deps.store, sourceReview, rootDir, now),
+            });
+        }
+        const report = buildReport(suite, taskResults, minSamples, minFailureDelta);
+        if (options.eventsPath)
+            await writeAntiGeneBenchmarkResult(report, options.eventsPath, now);
+        return report;
+    }
+    finally {
+        rmSync(rootDir, { recursive: true, force: true });
+    }
+}
+export async function writeAntiGeneBenchmarkResult(report, eventsPath, now = Date.now) {
+    const ingestor = new Ingestor({ path: eventsPath, now });
+    try {
+        await ingestReportPayload(ingestor, report);
+    }
+    catch (error) {
+        if (!(error instanceof LineTooLargeError))
+            throw error;
+        await ingestReportPayload(ingestor, compactReportPayload(report, 5));
+    }
+}
+async function ingestReportPayload(ingestor, payload) {
+    await ingestor.ingest({
+        type: 'anti_gene.benchmark_result',
+        human: { title: `anti-gene benchmark ${payload.suite}` },
+        payload: payload,
+        actor: { kind: 'machine', id: 'anti-gene-benchmark' },
+    });
+}
+function compactWarnings(items) {
+    return items.slice(0, 3);
+}
+function compactRunResult(result) {
+    return {
+        ...result,
+        observedAntiWarnings: compactWarnings(result.observedAntiWarnings),
+        missingExpectedWarnings: compactWarnings(result.missingExpectedWarnings),
+    };
+}
+function compactReportPayload(report, maxTasks) {
+    return {
+        ...report,
+        taskResults: report.taskResults.slice(0, maxTasks).map((task) => ({
+            taskId: task.taskId,
+            baseline: compactRunResult(task.baseline),
+            antiGene: compactRunResult(task.antiGene),
+        })),
+        taskResultsTruncated: Math.max(0, report.taskResults.length - maxTasks),
+    };
+}
+function isReportPayload(value) {
+    return !!value && typeof value === 'object'
+        && typeof value.suite === 'string'
+        && typeof value.tasks === 'number'
+        && typeof value.verdict === 'string';
+}
+export function antiGeneBenchmarkReportsFromEvents(events) {
+    const out = [];
+    for (const event of events) {
+        if (event.type !== 'anti_gene.benchmark_result')
+            continue;
+        if (isReportPayload(event.payload))
+            out.push(event.payload);
+    }
+    return out;
+}
+export function latestAntiGeneBenchmarkReport(events) {
+    const reports = antiGeneBenchmarkReportsFromEvents(events);
+    return reports[reports.length - 1] ?? null;
+}