@hmharness/evolution 0.14.9 → 0.14.10

package/dist/candidates.js.v2bak.v2bak

@@ -1,232 +0,0 @@
-/**
- * @hmharness/evolution - candidates (V2 M9: Evolution 泛化)
- * Blueprint M9: a typed candidate registry (prompt/skill/context/tool_policy/
- * model_router/workflow/harness), a Control/Treatment experiment runner,
- * statistical comparison, and gated promotion/rollback. See ADR-0003.
- *
- * 红线 (blueprint 14.3, enforced here, not by convention):
- *  - 无实验报告(promote-eligible)不晋升 —— no baseline, no improvement claim
- *  - 激活前必写 previous 指针 —— no rollback, no promotion
- *  - origin=agent 的 prompt/harness 候选需人工标记才可激活 —— agents never
- *    self-modify the production prompt
- *  - 晋升判据是双比例检验,LLM self-report 无效力 —— M2 证据阶梯双保险
- */
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { screenForPoison } from "./evolve.js";
-export const CANDIDATE_TARGETS = [
-    'prompt', 'skill', 'context', 'tool_policy', 'model_router', 'workflow', 'harness',
-];
-/* ---------------- registry ---------------- */
-function candDir(home) {
-    return join(home, 'evolution', 'candidates');
-}
-export async function registerCandidate(home, cand) {
-    if (!CANDIDATE_TARGETS.includes(cand.target))
-        throw new Error(`unknown candidate target: ${cand.target}`);
-    if (!cand.hypothesis.trim() || !cand.candidateVersion.trim())
-        throw new Error('candidate needs a hypothesis and a candidateVersion');
-    const poison = screenForPoison(cand.hypothesis + '\n' + (cand.payload ?? ''));
-    if (poison)
-        throw new Error(`candidate rejected by safety screen: ${poison}`);
-    const full = {
-        ...cand,
-        id: cand.id ?? `cand_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
-        createdAt: new Date().toISOString(),
-    };
-    await mkdir(candDir(home), { recursive: true });
-    await writeFile(join(candDir(home), `${full.id}.json`), JSON.stringify(full, null, 2) + '\n', 'utf8');
-    return full;
-}
-export async function listCandidates(home) {
-    let files = [];
-    try {
-        files = (await readdir(candDir(home))).filter((f) => f.endsWith('.json'));
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const f of files) {
-        try {
-            out.push(JSON.parse(await readFile(join(candDir(home), f), 'utf8')));
-        }
-        catch { /* skip torn */ }
-    }
-    return out.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
-}
-export async function getCandidate(home, id) {
-    try {
-        return JSON.parse(await readFile(join(candDir(home), `${id}.json`), 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-/* ---------------- statistics ---------------- */
-/** Standard normal CDF, Zelen & Severo approximation of A&S 26.2.17 (|err|<7.5e-8). */
-function normalCdf(z) {
-    const t = 1 / (1 + 0.2316419 * Math.abs(z));
-    const d = Math.exp(-z * z / 2) / Math.sqrt(2 * Math.PI);
-    const poly = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
-    const upper = d * poly; // P(Z > |z|) tail
-    return z >= 0 ? 1 - upper : upper;
-}
-/** Two-proportion two-sided test (treatment vs control pass rates). */
-export function twoProportionTest(control, treatment) {
-    if (control.n <= 0 || treatment.n <= 0)
-        return { z: 0, p: 1, diff: 0 };
-    const pc = control.pass / control.n;
-    const pt = treatment.pass / treatment.n;
-    const pool = (control.pass + treatment.pass) / (control.n + treatment.n);
-    const se = Math.sqrt(pool * (1 - pool) * (1 / control.n + 1 / treatment.n));
-    const z = se > 0 ? (pt - pc) / se : 0;
-    return { z, p: 2 * (1 - normalCdf(Math.abs(z))), diff: pt - pc };
-}
-/** Per-arm minimum before any verdict counts (aligned with impact.ts canary
- *  threshold: >=8 sessions, and blueprint "one success is not significance"). */
-export const MIN_ARM_N = 8;
-export function verdictFor(control, treatment) {
-    const { z, p, diff } = twoProportionTest(control, treatment);
-    if (control.n < MIN_ARM_N || treatment.n < MIN_ARM_N) {
-        return { verdict: 'needs-data', reason: `samples below ${MIN_ARM_N} per arm (control ${control.n}, treatment ${treatment.n})`, z, p, diff };
-    }
-    if (p < 0.05 && diff >= 0.10)
-        return { verdict: 'promote-eligible', reason: `significant lift (p=${p.toFixed(4)}, diff=${(diff * 100).toFixed(1)}%)`, z, p, diff };
-    if ((p < 0.05 && diff <= -0.05) || diff <= -0.10) {
-        return { verdict: 'reject', reason: `regression (p=${p.toFixed(4)}, diff=${(diff * 100).toFixed(1)}%)`, z, p, diff };
-    }
-    return { verdict: 'needs-data', reason: `no significant difference (p=${p.toFixed(4)}, diff=${(diff * 100).toFixed(1)}%)`, z, p, diff };
-}
-export async function runCandidateExperiment(home, candidateId, opts) {
-    const cand = await getCandidate(home, candidateId);
-    if (!cand)
-        throw new Error(`no candidate: ${candidateId}`);
-    // holdout cases are excluded from promotion gates (bench.ts anti-memorization)
-    const gate = opts.cases.filter((c) => !c.holdout).slice(0, Math.max(1, opts.maxCases ?? 12));
-    let cPass = 0, cTok = 0, tPass = 0, tTok = 0;
-    // per-case rows (day-56 observability: which case flipped is the whole
-    // point of a diff - aggregates alone cannot answer it)
-    const ctlRows = [];
-    const trtRows = [];
-    for (const c of gate) {
-        const ctl = await opts.runCase(c, 'control');
-        if (ctl.pass)
-            cPass++;
-        cTok += ctl.tokens;
-        ctlRows.push({ name: c.name, pass: ctl.pass, tokens: ctl.tokens });
-        const trt = await opts.runCase(c, 'treatment');
-        if (trt.pass)
-            tPass++;
-        tTok += trt.tokens;
-        trtRows.push({ name: c.name, pass: trt.pass, tokens: trt.tokens });
-    }
-    const v = verdictFor({ pass: cPass, n: gate.length }, { pass: tPass, n: gate.length });
-    const report = {
-        candidateId,
-        ranAt: new Date().toISOString(),
-        cases: gate.length,
-        control: { pass: cPass, n: gate.length, passRate: gate.length ? cPass / gate.length : 0, tokens: cTok, results: ctlRows },
-        treatment: { pass: tPass, n: gate.length, passRate: gate.length ? tPass / gate.length : 0, tokens: tTok, results: trtRows },
-        ...v,
-    };
-    const dir = join(home, 'evolution', 'experiments', candidateId);
-    await mkdir(dir, { recursive: true });
-    await writeFile(join(dir, `${report.ranAt.replace(/[:.]/g, '-')}.json`), JSON.stringify(report, null, 2) + '\n', 'utf8');
-    return report;
-}
-/** Latest experiment report for a candidate (promotion evidence). */
-export async function latestExperiment(home, candidateId) {
-    const dir = join(home, 'evolution', 'experiments', candidateId);
-    let files = [];
-    try {
-        files = (await readdir(dir)).filter((f) => f.endsWith('.json')).sort();
-    }
-    catch {
-        return null;
-    }
-    if (files.length === 0)
-        return null;
-    try {
-        return JSON.parse(await readFile(join(dir, files[files.length - 1]), 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-const activeDir = (home) => join(home, 'evolution', 'active');
-export async function activeVersions(home) {
-    const out = {};
-    let files = [];
-    try {
-        files = await readdir(activeDir(home));
-    }
-    catch {
-        return out;
-    }
-    for (const f of files.filter((f) => f.endsWith('.json') && !f.endsWith('.previous.json'))) {
-        try {
-            const v = JSON.parse(await readFile(join(activeDir(home), f), 'utf8'));
-            out[v.target] = v;
-        }
-        catch { /* skip torn */ }
-    }
-    return out;
-}
-/** Blueprint gates, enforced: latest report must be promote-eligible, a
- *  previous pointer is written BEFORE activation, agent-origin prompt/harness
- *  candidates need approvedByHuman. Skill promotions ride the existing
- *  promoteSkill canary channel. */
-export async function promoteCandidate(home, candidateId, opts = {}) {
-    const cand = await getCandidate(home, candidateId);
-    if (!cand)
-        return { ok: false, error: `no candidate: ${candidateId}` };
-    const report = await latestExperiment(home, candidateId);
-    if (!report)
-        return { ok: false, error: 'no experiment report - run the experiment first (no baseline, no promotion)' };
-    if (report.verdict !== 'promote-eligible') {
-        return { ok: false, error: `latest report verdict is ${report.verdict} (${report.reason}) - not promotable` };
-    }
-    if ((cand.target === 'prompt' || cand.target === 'harness') && cand.origin === 'agent' && !opts.approvedByHuman) {
-        return { ok: false, error: 'agent-origin prompt/harness candidate requires approvedByHuman (production prompt is not agent-writable)' };
-    }
-    await mkdir(activeDir(home), { recursive: true });
-    const cur = await activeVersions(home);
-    const previous = cur[cand.target];
-    if (previous) {
-        await writeFile(join(activeDir(home), `${cand.target}.previous.json`), JSON.stringify(previous, null, 2) + '\n', 'utf8');
-    }
-    if (cand.target === 'skill') {
-        // payload = skill name; the audited canary channel stays the only skill path
-        const { promoteSkill } = await import("./skills.js");
-        if (!cand.payload)
-            return { ok: false, error: 'skill candidate has no payload (skill name)' };
-        await promoteSkill(home, cand.payload, { canary: true });
-    }
-    const active = {
-        target: cand.target,
-        version: cand.candidateVersion,
-        candidateId: cand.id,
-        since: new Date().toISOString(),
-        reportAt: report.ranAt,
-    };
-    await writeFile(join(activeDir(home), `${cand.target}.json`), JSON.stringify(active, null, 2) + '\n', 'utf8');
-    return { ok: true, active };
-}
-export async function rollbackCandidate(home, target) {
-    const dir = activeDir(home);
-    const prevPath = join(dir, `${target}.previous.json`);
-    let previous = null;
-    try {
-        previous = JSON.parse(await readFile(prevPath, 'utf8'));
-    }
-    catch { /* no previous */ }
-    if (!previous)
-        return { ok: false, error: `no previous pointer for ${target} - nothing to roll back to` };
-    if (target === 'skill') {
-        const { rollbackSkill } = await import("./skills.js");
-        await rollbackSkill(home, previous.version);
-    }
-    await writeFile(join(dir, `${target}.json`), JSON.stringify(previous, null, 2) + '\n', 'utf8');
-    return { ok: true };
-}

package/dist/dataset.d.ts.v2bak.v2bak

@@ -1,64 +0,0 @@
-export interface DatasetSample {
-    runId: string;
-    task: string;
-    outcome: string;
-    turns: number;
-    toolUses: number;
-    toolFailRate: number;
-    toolsUsed: string[];
-    model: string;
-    /** evidence rank from the M2 ladder when the run was evaluated (0 = none) */
-    evidenceRank: number;
-    /** interpretable reward in [0,1]; llm-judged runs never reach 1.0 (M2 cap) */
-    reward: number;
-    /** evaluation notes / failure snippets attach here (bounded) */
-    evidence?: string;
-    split: 'train' | 'eval';
-}
-export interface DatasetManifest {
-    version: string;
-    createdAt: string;
-    /** inclusive run-id scan window (first..last seen, lexicographic) */
-    runWindow: {
-        first: string | null;
-        last: string | null;
-    };
-    filterFingerprint: string;
-    splitSeed: number;
-    splitRatio: number;
-    counts: {
-        scanned: number;
-        kept: number;
-        dropped: number;
-        duplicates: number;
-        train: number;
-        eval: number;
-    };
-    rewardHistogram: Record<string, number>;
-}
-export interface DatasetBuildResult {
-    manifest: DatasetManifest;
-    dir: string;
-}
-/** Interpretable reward mapping (ADR-0004): ok runs start at 1.0 and lose
- *  0.1 per 20% tool-failure rate; non-ok runs cap at 0.3. Evidence rank
- *  from the M2 ladder nudges confidence but never creates a free perfect. */
-export declare function rewardFor(outcome: string, toolFailRate: number, evidenceRank?: number): number;
-/** Stable fingerprint of the filter config - manifest must be reproducible. */
-export declare function filterFingerprint(opts: {
-    keepOutcome?: string[];
-    minTurns?: number;
-}): string;
-/** Deterministic hash-based split (same run always lands in the same half). */
-export declare function splitFor(runId: string, seed: number, evalRatio?: number): 'train' | 'eval';
-export interface BuildDatasetOptions {
-    version?: string;
-    /** outcomes to keep; default keeps everything labeled */
-    keepOutcome?: string[];
-    minTurns?: number;
-    evalRatio?: number;
-    splitSeed?: number;
-}
-export declare function buildDataset(home: string, opts?: BuildDatasetOptions): Promise<DatasetBuildResult>;
-export declare function listDatasets(home: string): Promise<DatasetManifest[]>;
-export declare function loadDataset(home: string, version: string, split?: 'train' | 'eval'): Promise<DatasetSample[]>;

package/dist/dataset.js.v2bak.v2bak

@@ -1,184 +0,0 @@
-/**
- * @hmharness/evolution - dataset (V2 M10: Trajectory → Dataset Version)
- * Pure data engineering, zero model calls. Pipeline per blueprint:
- *   Trajectory → Filter → Deduplicate → Label → Evidence Attach → Reward
- *   → Dataset Version → Train/Eval Split
- * Source of truth: HMH_HOME/runs/<run-id>/ (M1 trajectory recorder's
- * summary.json + trajectory.jsonl). Output: versioned, redacted, split
- * under evolution/datasets/<version>/. See ADR-0004.
- */
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { join } from 'node:path';
-import { redactSecrets } from "./insights.js";
-const RUNS_DIR = 'runs';
-/** Interpretable reward mapping (ADR-0004): ok runs start at 1.0 and lose
- *  0.1 per 20% tool-failure rate; non-ok runs cap at 0.3. Evidence rank
- *  from the M2 ladder nudges confidence but never creates a free perfect. */
-export function rewardFor(outcome, toolFailRate, evidenceRank = 0) {
-    let r;
-    if (outcome === 'ok') {
-        r = 1.0 - Math.min(0.6, Math.round(toolFailRate * 10) / 10);
-    }
-    else {
-        r = Math.max(0, 0.3 - Math.round(toolFailRate * 10) / 10);
-    }
-    // llm-judge ladder ranks (5+) can never mint a perfect sample
-    if (evidenceRank >= 5)
-        r = Math.min(r, 0.7);
-    return Math.max(0, Math.min(1, r));
-}
-/** Stable fingerprint of the filter config - manifest must be reproducible. */
-export function filterFingerprint(opts) {
-    return createHash('sha256').update(JSON.stringify({
-        keepOutcome: opts.keepOutcome ?? ['ok', 'turn-budget', 'error'],
-        minTurns: opts.minTurns ?? 1,
-        redact: true,
-    })).digest('hex').slice(0, 12);
-}
-/** Normalize both the recorder schema (outcome object + metrics block) and
- *  the flat test/hand-written shape into one view. */
-function normalizeSummary(s) {
-    const outcome = typeof s.outcome === 'string'
-        ? s.outcome
-        : (s.outcome?.success ? 'ok' : String(s.outcome?.reason ?? ''));
-    return {
-        task: String(s.task ?? ''),
-        outcome,
-        turns: Number(s.turns ?? s.metrics?.turns ?? 0),
-        toolUses: Number(s.toolUses ?? s.metrics?.toolUses ?? 0),
-        toolFailures: Number(s.toolFailures ?? s.metrics?.toolFailures ?? 0),
-        toolsUsed: s.toolsUsed ?? [],
-        model: String(s.model ?? ''),
-        rank: Number(s.evidence?.rank ?? 0),
-        detail: String(s.evidence?.detail ?? ''),
-    };
-}
-async function readRunSummaries(home) {
-    const root = join(home, RUNS_DIR);
-    let ids = [];
-    try {
-        ids = (await readdir(root)).filter((d) => !d.startsWith('.'));
-    }
-    catch {
-        return [];
-    }
-    ids.sort();
-    const out = [];
-    for (const id of ids) {
-        try {
-            const s = JSON.parse(await readFile(join(root, id, 'summary.json'), 'utf8'));
-            out.push({ runId: id, summary: s });
-        }
-        catch { /* torn or absent summary - not a dataset candidate */ }
-    }
-    return out;
-}
-/** Deterministic hash-based split (same run always lands in the same half). */
-export function splitFor(runId, seed, evalRatio = 0.2) {
-    const h = createHash('sha256').update(`${seed}:${runId}`).digest();
-    const v = h.readUInt32BE(0) / 0xffffffff;
-    return v < evalRatio ? 'eval' : 'train';
-}
-export async function buildDataset(home, opts = {}) {
-    const keep = opts.keepOutcome ?? ['ok', 'turn-budget', 'error'];
-    const minTurns = opts.minTurns ?? 1;
-    const evalRatio = opts.evalRatio ?? 0.2;
-    const seed = opts.splitSeed ?? 20260913;
-    const runs = await readRunSummaries(home);
-    const fp = filterFingerprint({ keepOutcome: keep, minTurns });
-    const byFingerprint = new Map();
-    let dropped = 0;
-    let duplicates = 0;
-    for (const { runId, summary } of runs) {
-        const n = normalizeSummary(summary);
-        if (!n.outcome || !keep.includes(n.outcome) || n.turns < minTurns) {
-            dropped++;
-            continue;
-        }
-        const fpRun = createHash('sha256').update(`${n.task}|${n.outcome}|${n.turns}|${n.toolsUsed.join(',')}`, 'utf8').digest('hex').slice(0, 16);
-        if (byFingerprint.has(fpRun)) {
-            duplicates++;
-            continue;
-        } // keep first (oldest) - newest is a rerun of the same shape
-        byFingerprint.set(fpRun, { runId, summary });
-    }
-    const samples = [];
-    const histogram = {};
-    for (const { runId, summary } of byFingerprint.values()) {
-        const n = normalizeSummary(summary);
-        const failRate = n.toolUses > 0 ? n.toolFailures / n.toolUses : 0;
-        const reward = rewardFor(n.outcome, failRate, n.rank);
-        const bucket = reward.toFixed(1);
-        histogram[bucket] = (histogram[bucket] ?? 0) + 1;
-        samples.push({
-            runId,
-            task: redactSecrets(n.task),
-            outcome: n.outcome,
-            turns: n.turns,
-            toolUses: n.toolUses,
-            toolFailRate: Math.round(failRate * 100) / 100,
-            toolsUsed: n.toolsUsed,
-            model: n.model,
-            evidenceRank: n.rank,
-            reward,
-            ...(n.detail ? { evidence: redactSecrets(n.detail).slice(0, 400) } : {}),
-            split: splitFor(runId, seed, evalRatio),
-        });
-    }
-    samples.sort((a, b) => (a.runId < b.runId ? -1 : 1));
-    const version = opts.version ?? `v-${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)}`;
-    const dir = join(home, 'evolution', 'datasets', version);
-    await mkdir(dir, { recursive: true });
-    await writeFile(join(dir, 'samples.jsonl'), samples.map((s) => JSON.stringify(s)).join('\n') + (samples.length ? '\n' : ''), 'utf8');
-    const manifest = {
-        version,
-        createdAt: new Date().toISOString(),
-        runWindow: { first: runs[0]?.runId ?? null, last: runs[runs.length - 1]?.runId ?? null },
-        filterFingerprint: fp,
-        splitSeed: seed,
-        splitRatio: evalRatio,
-        counts: {
-            scanned: runs.length,
-            kept: samples.length,
-            dropped,
-            duplicates,
-            train: samples.filter((s) => s.split === 'train').length,
-            eval: samples.filter((s) => s.split === 'eval').length,
-        },
-        rewardHistogram: histogram,
-    };
-    await writeFile(join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', 'utf8');
-    return { manifest, dir };
-}
-export async function listDatasets(home) {
-    const root = join(home, 'evolution', 'datasets');
-    let vers = [];
-    try {
-        vers = (await readdir(root)).filter((d) => d.startsWith('v-'));
-    }
-    catch {
-        return [];
-    }
-    vers.sort();
-    const out = [];
-    for (const v of vers) {
-        try {
-            out.push(JSON.parse(await readFile(join(root, v, 'manifest.json'), 'utf8')));
-        }
-        catch { /* skip torn */ }
-    }
-    return out;
-}
-export async function loadDataset(home, version, split) {
-    const file = join(home, 'evolution', 'datasets', version, 'samples.jsonl');
-    let text;
-    try {
-        text = await readFile(file, 'utf8');
-    }
-    catch {
-        return [];
-    }
-    return text.split('\n').filter(Boolean).map((l) => JSON.parse(l))
-        .filter((s) => !split || s.split === split);
-}

package/dist/evolve.d.ts.v2bak.v2bak

@@ -1,98 +0,0 @@
-import { type ProviderConfig } from '@hmharness/kernel';
-import { type BenchCase } from './bench.ts';
-export interface SkillProposal {
-    name: string;
-    description: string;
-    skill_md: string;
-}
-export interface ProposalOutcome {
-    name: string;
-    action: 'promoted' | 'rejected' | 'error';
-    reason: string;
-    baseline?: {
-        passRate: number;
-        cases: string;
-    };
-    candidate?: {
-        passRate: number;
-        cases: string;
-    };
-    holdout?: {
-        baselineRate: number;
-        candidateRate: number;
-    };
-    /** P0 lineage ledger: what fed this decision (provenance for impact
-     *  attribution - which insights produced which skill, with which scores).
-     *  Evolution-artifact genealogy is the GEPA/DGM archive lesson: decisions
-     *  without ancestry cannot be audited for objective hacking. */
-    lineage?: {
-        parentInsights: string[];
-        scores: {
-            train: number;
-            holdout?: number;
-        };
-        metaModel: string;
-        decidedAt: string;
-    };
-}
-export interface EvolveReport {
-    time: string;
-    model: string;
-    seededCases: string[];
-    insightCount: number;
-    noteCount: number;
-    proposals: SkillProposal[];
-    outcomes: ProposalOutcome[];
-    memoryDistilled: string | null;
-    /** code-level evolution: proposed patches (DGM bridge) */
-    codePatches?: Array<{
-        name: string;
-        file: string;
-        reason: string;
-    }>;
-    /** code-level outcomes: merged/reverted/error per patch */
-    patchOutcomes?: Array<{
-        name: string;
-        action: string;
-        reason: string;
-        branch?: string;
-    }>;
-    /** P0 impact attribution: canary A/B comparison applied this cycle */
-    impact?: {
-        rows: Array<{
-            skill: string;
-            exposed: string;
-            control: string;
-            verdict: string;
-        }>;
-        applied: string[];
-    };
-    /** P1 lifecycle: skills moved to dormant this cycle */
-    decayed?: string[];
-    /** budget state at cycle start (observability) */
-    budget?: {
-        cyclesToday: number;
-        maxCyclesPerDay?: number;
-    };
-    /** chars/4 estimate of this cycle's meta-call traffic; feeds the daily
-     *  token budget gate (readBudget sums today's entries) */
-    estTokens?: number;
-}
-/** Runs one bench case with the given skills block injected. */
-export type CaseRunner = (c: BenchCase, skillsPrompt: string) => Promise<string>;
-/** Rough token estimate, language-aware: ASCII runs ~4 chars/token, CJK
- * ~1 char/token. A flat chars/4 undercounted Chinese 2-4x, letting verbose
- * zh candidates dodge the cost cap. Used on BOTH sides of every comparison
- * (baseline and candidate), never as the only rejection reason (the
- * pass-rate gate decides; cost-cap only vetoes pass-by-rambling). */
-export declare function estTokens(text: string): number;
-export declare function runEvolution(opts: {
-    home: string;
-    provider: ProviderConfig;
-    runCase: CaseRunner;
-    maxProposals?: number;
-    /** Skip the meta-model call and evaluate these proposals directly (tests / future UIs). */
-    presetProposals?: SkillProposal[];
-    log?: (line: string) => void;
-}): Promise<EvolveReport>;
-export declare function screenForPoison(text: string): string | null;