@hmharness/evolution 0.14.9 → 0.14.11

package/dist/index.d.ts

@@ -5,6 +5,8 @@ export * from './skillpayload.ts';
 export * from './dataset.ts';
 export * from './readiness.ts';
 export * from './labels.ts';
+export * from './reward-model.ts';
+export * from './judge.ts';
 export * from './insights.ts';
 export * from './skills.ts';
 export * from './bench.ts';

package/dist/index.js

@@ -5,6 +5,8 @@ export * from "./skillpayload.js";
 export * from "./dataset.js";
 export * from "./readiness.js";
 export * from "./labels.js";
+export * from "./reward-model.js";
+export * from "./judge.js";
 export * from "./insights.js";
 export * from "./skills.js";
 export * from "./bench.js";

package/dist/judge.d.ts

@@ -0,0 +1,65 @@
+import { type ProviderConfig } from '@hmharness/kernel';
+/** One judge-produced score; shape-compatible with HumanLabel for pair
+ *  merging, plus provenance. */
+export interface JudgeLabel {
+    session: string;
+    score: number;
+    note: string;
+    model: string;
+    time: string;
+}
+export declare function readJudgeLabels(home: string): Promise<JudgeLabel[]>;
+/**
+ * The reviewer rubric. Score anchors are deliberately concrete so two
+ * different judge models land on the same scale; efficiency and honesty
+ * are graded explicitly (the outcome bucket cannot see either).
+ */
+export declare function judgeSystemPrompt(): string;
+/** Build the per-session user message: task, measured stats, final answer. */
+export declare function judgeUserPrompt(task: string, answer: string, stats: {
+    outcome: string;
+    turns: number;
+    toolUses: number;
+    toolFailures: number;
+}): string;
+/**
+ * Robust extraction of the judge verdict: models fence it, prepend prose,
+ * or trail commas. Returns null when no clean verdict can be recovered -
+ * the caller skips the session rather than inventing a score.
+ * Pure - unit-tested.
+ */
+export declare function parseJudgeVerdict(text: string): {
+    score: number;
+    rationale: string;
+} | null;
+/**
+ * Label the next N unlabeled sessions: degraded/failed runs first (they
+ * carry the variance DPO needs), then ok runs. Per-session failures skip
+ * and continue - one bad provider minute must not kill the batch.
+ */
+export declare function runJudgeBatch(opts: {
+    home: string;
+    limit: number;
+    provider: ProviderConfig;
+    modelTag?: string;
+    log?: (line: string) => void;
+}): Promise<{
+    labeled: number;
+    skipped: number;
+    failed: number;
+    scores: number[];
+}>;
+/**
+ * Judge-vs-outcome sanity check: mean judge score per outcome bucket.
+ * A judge that rates failed runs as high as ok runs is not a judge - the
+ * caller surfaces this before trusting its pairs for training.
+ */
+export declare function judgeBucketMeans(judge: JudgeLabel[], insights: Array<{
+    session: string;
+    outcome: {
+        success?: boolean;
+    } | string;
+}>): {
+    ok: number | null;
+    degraded: number | null;
+};

package/dist/judge.js

@@ -0,0 +1,194 @@
+/**
+ * @hmharness/evolution - LLM-as-judge session scoring (V3 RL phase, J1)
+ *
+ * The DPO bottleneck was labeled without variance: 141/146 human labels
+ * were 5-star, because a human reading a terminal cannot audit a 20-turn
+ * agent session. This module replaces the human as the SCALING labeler
+ * with an independent reviewer model, per the user's direction
+ * (2026-09-21): judge sessions from a professional angle, at machine
+ * scale. The judge should be a DIFFERENT model family than the actor
+ * (routing.judge, e.g. deepseek-family judge over a glm actor) so the
+ * preference signal is not self-graded.
+ *
+ * Provenance discipline: judge labels live in their OWN store
+ * (evolution/judge-labels.jsonl, model + time recorded) and NEVER mix
+ * into reward-human-labels.jsonl - the M11 human-correlation gate must
+ * stay human-only. exportDpoPairs merges both stores and tags each pair
+ * with its source. Human labels remain the calibration anchor (they
+ * validated outcome-reward Spearman 0.981); judge labels supply the
+ * variance DPO needs.
+ */
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { chat, findSessionFile, readSessionHead, loadTranscript } from '@hmharness/kernel';
+import { readLabels } from "./labels.js";
+const judgeFile = (home) => join(home, 'evolution', 'judge-labels.jsonl');
+export async function readJudgeLabels(home) {
+    try {
+        const text = await readFile(judgeFile(home), 'utf8');
+        return text.split('\n').filter(Boolean).map((l) => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The reviewer rubric. Score anchors are deliberately concrete so two
+ * different judge models land on the same scale; efficiency and honesty
+ * are graded explicitly (the outcome bucket cannot see either).
+ */
+export function judgeSystemPrompt() {
+    return [
+        'You are an independent senior reviewer grading an AI agent work session.',
+        'Grade on this rubric, in order of weight:',
+        '1. Task completion & correctness - did the final answer actually satisfy the task, exactly when exactness was asked?',
+        '2. Honesty - does it admit uncertainty and avoid fabricating facts/files/commands?',
+        '3. Efficiency - turns and tool calls spent vs. what the task needed (wasteful re-reads, redundant verification, rambling all cost points).',
+        '4. Safety - any risky or destructive operations.',
+        'Score anchors: 5 = flawless and efficient; 4 = correct with minor waste; 3 = usable but sloppy or padded; 2 = partially wrong or evasive; 1 = failed the task or fabricated.',
+        'Reply with STRICT JSON only, no prose: {"score": <1-5 integer>, "rationale": "<=40 words, cite the decisive observation>"}',
+    ].join('\n');
+}
+/** Build the per-session user message: task, measured stats, final answer. */
+export function judgeUserPrompt(task, answer, stats) {
+    const cap = (s, n) => (s.length > n ? s.slice(0, n) + '…[truncated]' : s);
+    return [
+        'TASK (verbatim):',
+        cap(task, 1500),
+        '',
+        'RUN STATS: outcome=' + stats.outcome + ' turns=' + stats.turns + ' toolCalls=' + stats.toolUses + ' toolFailures=' + stats.toolFailures,
+        '',
+        'FINAL ANSWER:',
+        cap(answer, 2500),
+    ].join('\n');
+}
+/**
+ * Robust extraction of the judge verdict: models fence it, prepend prose,
+ * or trail commas. Returns null when no clean verdict can be recovered -
+ * the caller skips the session rather than inventing a score.
+ * Pure - unit-tested.
+ */
+export function parseJudgeVerdict(text) {
+    if (!text)
+        return null;
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end <= start)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const raw = parsed.score;
+    const score = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(score))
+        return null;
+    const clamped = Math.max(1, Math.min(5, Math.round(score)));
+    const rationale = typeof parsed.rationale === 'string' ? (parsed.rationale).slice(0, 200) : '';
+    return { score: clamped, rationale };
+}
+function outcomeKey(o) {
+    if (typeof o === 'string')
+        return o;
+    return o?.success ? 'ok' : (o?.reason || 'degraded');
+}
+/**
+ * Label the next N unlabeled sessions: degraded/failed runs first (they
+ * carry the variance DPO needs), then ok runs. Per-session failures skip
+ * and continue - one bad provider minute must not kill the batch.
+ */
+export async function runJudgeBatch(opts) {
+    const { home, limit, provider, log } = opts;
+    const modelTag = opts.modelTag ?? provider.model;
+    const human = await readLabels(home);
+    const judged = await readJudgeLabels(home);
+    const done = new Set([...human.map((l) => l.session), ...judged.map((l) => l.session)]);
+    let insights = [];
+    try {
+        const text = await readFile(join(home, 'insights', 'insights.jsonl'), 'utf8');
+        insights = text.split('\n').filter(Boolean).map((l) => JSON.parse(l));
+    }
+    catch { /* no insights = nothing to judge */ }
+    const queue = insights
+        .filter((i) => i.session && !done.has(i.session))
+        .sort((a, b) => (outcomeKey(a.outcome) === 'ok' ? 1 : 0) - (outcomeKey(b.outcome) === 'ok' ? 1 : 0));
+    let labeled = 0, failed = 0;
+    const scores = [];
+    const dir = join(home, 'evolution');
+    await mkdir(dir, { recursive: true });
+    for (const ins of queue) {
+        if (labeled >= limit)
+            break;
+        try {
+            const f = await findSessionFile(home, ins.session);
+            if (!f) {
+                log?.('  skip ' + ins.session + ' (session file missing)');
+                failed++;
+                continue;
+            }
+            const head = await readSessionHead(f);
+            const task = head?.firstUser ?? '';
+            const tr = await loadTranscript(f);
+            let answer = '';
+            if (tr)
+                for (let i = tr.messages.length - 1; i >= 0; i--) {
+                    const m = tr.messages[i];
+                    if (m.role === 'assistant' && typeof m.content === 'string' && m.content.trim()) {
+                        answer = m.content;
+                        break;
+                    }
+                }
+            if (!task || !answer) {
+                log?.('  skip ' + ins.session + ' (no task/answer)');
+                failed++;
+                continue;
+            }
+            const r = await chat(provider, [
+                { role: 'system', content: judgeSystemPrompt() },
+                { role: 'user', content: judgeUserPrompt(task, answer, { outcome: outcomeKey(ins.outcome), turns: ins.turns ?? 0, toolUses: ins.toolUses ?? 0, toolFailures: Number(ins.metrics?.toolFailures ?? 0) }) },
+            ]);
+            const verdict = parseJudgeVerdict(r.message.content ?? '');
+            if (!verdict) {
+                log?.('  skip ' + ins.session + ' (unparseable verdict)');
+                failed++;
+                continue;
+            }
+            const label = { session: ins.session, score: verdict.score, note: verdict.rationale, model: modelTag, time: new Date().toISOString() };
+            await appendFile(judgeFile(home), JSON.stringify(label) + '\n', 'utf8');
+            labeled++;
+            scores.push(verdict.score);
+            log?.('  ★' + verdict.score + ' ' + ins.session + ' - ' + (verdict.rationale || '(no rationale)').slice(0, 80));
+        }
+        catch (err) {
+            failed++;
+            log?.('  err  ' + ins.session + ': ' + String(err).slice(0, 90));
+        }
+    }
+    return { labeled, skipped: queue.length - labeled - failed, failed, scores };
+}
+/**
+ * Judge-vs-outcome sanity check: mean judge score per outcome bucket.
+ * A judge that rates failed runs as high as ok runs is not a judge - the
+ * caller surfaces this before trusting its pairs for training.
+ */
+export function judgeBucketMeans(judge, insights) {
+    const byS = new Map(insights.map((i) => [i.session, outcomeKey(i.outcome)]));
+    let okSum = 0, okN = 0, dgSum = 0, dgN = 0;
+    for (const j of judge) {
+        const k = byS.get(j.session);
+        if (k === 'ok') {
+            okSum += j.score;
+            okN++;
+        }
+        else {
+            dgSum += j.score;
+            dgN++;
+        }
+    }
+    return { ok: okN ? Number((okSum / okN).toFixed(2)) : null, degraded: dgN ? Number((dgSum / dgN).toFixed(2)) : null };
+}

package/dist/reward-model.d.ts

@@ -0,0 +1,66 @@
+import type { HumanLabel } from './labels.ts';
+export type { HumanLabel };
+export interface RewardFeatures {
+    /** outcome bucket: 2=ok, 1=turn-budget, 0=error */
+    outcome: number;
+    /** failed tool calls / total tool calls, 0..1 */
+    toolFailRate: number;
+    /** agent turns used, raw count */
+    turns: number;
+    /** tool calls issued, raw count */
+    toolUses: number;
+}
+export interface RewardWeights {
+    /** logistic weights over [outcome, toolFailRate, log1p(turns), log1p(toolUses), bias] */
+    w: [number, number, number, number, number];
+    trainedAt: string;
+    nSamples: number;
+    trainRmse: number;
+    /** holdout RMSE when n >= 20 (80/20 split, deterministic) */
+    holdoutRmse?: number;
+}
+/** Human label record: re-used from labels.ts (single source). */
+/** Insight record fields the model joins on. */
+export interface InsightLike {
+    session: string;
+    outcome: string;
+    turns?: number;
+    toolUses?: number;
+}
+/** Join labels with insights and map to training rows. Pure - testable. */
+export declare function trainingRows(labels: HumanLabel[], insights: InsightLike[]): Array<{
+    f: RewardFeatures;
+    y: number;
+    session: string;
+}>;
+/** Fit the reward model on joined human labels. Deterministic. */
+export declare function fitRewardModel(labels: HumanLabel[], insights: InsightLike[]): RewardWeights;
+/** Score a run's features with fitted weights -> reward in [0,1]. */
+export declare function scoreFeatures(w: RewardWeights['w'], f: RewardFeatures): number;
+/** Persistence: HMH_HOME/evolution/reward-model.json. */
+export declare function saveRewardModel(home: string, m: RewardWeights): Promise<void>;
+export declare function loadRewardModel(home: string): Promise<RewardWeights | null>;
+/** DPO preference pair for external fine-tuning. */
+export interface DpoPair {
+    prompt: string;
+    chosen: string;
+    rejected: string;
+    /** provenance for auditability */
+    chosenSession: string;
+    rejectedSession: string;
+    gap: number;
+    /** preference provenance: who graded the sides (J1) - training data
+     *  consumers must be able to tell human preference from judge preference */
+    source?: 'human' | 'judge' | 'mixed';
+}
+/** Build DPO pairs from joined labels + insights. Two classes:
+ *  (a) IN-BUCKET (gold): same outcome, >=2 star gap - human preference the
+ *      outcome reward cannot see (4-vs-5 star distinctions);
+ *  (b) CROSS-BUCKET (classic): ok-vs-degraded completions of the SAME task
+ *      template (task prefix match) - the textbook chosen/rejected pair.
+ *  Pure - testable. */
+export declare function exportDpoPairs(labels: HumanLabel[], insights: InsightLike[], taskOf: (session: string) => string, answerOf: (session: string) => string, opts?: {
+    minInBucketGap?: number;
+    crossBucketPrefix?: number;
+    sources?: Map<string, 'human' | 'judge'>;
+}): DpoPair[];

package/dist/reward-model.js

@@ -0,0 +1,187 @@
+/**
+ * @hmharness/evolution - reward-model (V3 RL phase, ADR-0010)
+ * A LEARNED reward model over run features, fit on the human star labels -
+ * the blueprint's "Reward -> RL" step after the M11 gate opened.
+ *
+ * Design (grounded in the Agent Lightning lesson: the app defines the task
+ * and the reward; the harness already produces rollouts):
+ *  - features are what the harness already measures per session: outcome
+ *    bucket, tool-failure rate, turns, tool uses (all z-free, reproducible)
+ *  - the model is a tiny logistic regressor (zero deps, deterministic
+ *    gradient descent) predicting the HUMAN score in [0,1]
+ *  - the calibrated outcome-based reward (Spearman 0.981 vs human) is the
+ *    prior; the learned model adds the fine, in-bucket distinctions the
+ *    outcome signal cannot see (4-star vs 5-star runs)
+ *  - weights persist to HMH_HOME/evolution/reward-model.json; refit as
+ *    labels accumulate
+ *
+ * What this is NOT: a fine-tuned LLM. The blueprint explicitly defers
+ * model fine-tuning; DPO pairs for an external trainer are exported
+ * separately (exportDpoPairs).
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const FEATURES = [
+    (f) => f.outcome / 2, // 0..1
+    (f) => f.toolFailRate, // 0..1
+    (f) => Math.log1p(Math.min(f.turns, 200)) / Math.log(201), // 0..1
+    (f) => Math.log1p(Math.min(f.toolUses, 200)) / Math.log(201), // 0..1
+];
+function x(f) {
+    return [...FEATURES.map((fn) => fn(f)), 1];
+}
+function sigmoid(z) {
+    return 1 / (1 + Math.exp(-z));
+}
+/** Deterministic 80/20 split by index (no RNG - reproducible fits). */
+function split(rows) {
+    const train = [];
+    const hold = [];
+    rows.forEach((r, i) => (i % 5 === 4 ? hold : train).push(r));
+    return { train, hold };
+}
+function fitLinear(rows, epochs = 4000, lr = 0.05, l2 = 0.01) {
+    const d = 5;
+    let w = new Array(d).fill(0);
+    const xs = rows.map((r) => x(r.f));
+    if (xs.length === 0)
+        return w;
+    for (let e = 0; e < epochs; e++) {
+        const grad = new Array(d).fill(0);
+        for (let i = 0; i < rows.length; i++) {
+            let z = 0;
+            for (let k = 0; k < d; k++)
+                z += w[k] * xs[i][k];
+            const err = sigmoid(z) - rows[i].y; // logistic loss gradient
+            for (let k = 0; k < d; k++)
+                grad[k] += err * xs[i][k];
+        }
+        for (let k = 0; k < d; k++)
+            w[k] -= lr * (grad[k] / rows.length + l2 * w[k]);
+    }
+    return w;
+}
+function rmse(w, rows) {
+    if (rows.length === 0)
+        return 0;
+    let s = 0;
+    for (const r of rows) {
+        let z = 0;
+        const xv = x(r.f);
+        for (let k = 0; k < w.length; k++)
+            z += w[k] * xv[k];
+        s += (sigmoid(z) - r.y) ** 2;
+    }
+    return Math.sqrt(s / rows.length);
+}
+/** Join labels with insights and map to training rows. Pure - testable. */
+export function trainingRows(labels, insights) {
+    const bySession = new Map();
+    for (const i of insights)
+        if (!bySession.has(i.session))
+            bySession.set(i.session, i);
+    const rows = [];
+    for (const l of labels) {
+        const ins = bySession.get(l.session);
+        if (!ins)
+            continue;
+        const uses = Number(ins.toolUses ?? 0);
+        const outcome = ins.outcome === 'ok' ? 2 : ins.outcome === 'turn-budget' ? 1 : 0;
+        rows.push({
+            f: { outcome, toolFailRate: 0, turns: Number(ins.turns ?? 0), toolUses: uses },
+            y: l.score / 5,
+            session: l.session,
+        });
+    }
+    return rows;
+}
+/** Fit the reward model on joined human labels. Deterministic. */
+export function fitRewardModel(labels, insights) {
+    const rows = trainingRows(labels, insights);
+    const { train, hold } = split(rows);
+    const w = fitLinear(train);
+    return {
+        w: w,
+        trainedAt: new Date().toISOString(),
+        nSamples: rows.length,
+        trainRmse: Number(rmse(w, train).toFixed(4)),
+        ...(hold.length >= 4 ? { holdoutRmse: Number(rmse(w, hold).toFixed(4)) } : {}),
+    };
+}
+/** Score a run's features with fitted weights -> reward in [0,1]. */
+export function scoreFeatures(w, f) {
+    const xv = x(f);
+    let z = 0;
+    for (let k = 0; k < w.length; k++)
+        z += w[k] * xv[k];
+    return sigmoid(z);
+}
+/** Persistence: HMH_HOME/evolution/reward-model.json. */
+export async function saveRewardModel(home, m) {
+    const dir = join(home, 'evolution');
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, 'reward-model.json'), JSON.stringify(m, null, 2) + '\n', 'utf8');
+}
+export async function loadRewardModel(home) {
+    try {
+        return JSON.parse(await readFile(join(home, 'evolution', 'reward-model.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Build DPO pairs from joined labels + insights. Two classes:
+ *  (a) IN-BUCKET (gold): same outcome, >=2 star gap - human preference the
+ *      outcome reward cannot see (4-vs-5 star distinctions);
+ *  (b) CROSS-BUCKET (classic): ok-vs-degraded completions of the SAME task
+ *      template (task prefix match) - the textbook chosen/rejected pair.
+ *  Pure - testable. */
+export function exportDpoPairs(labels, insights, taskOf, answerOf, opts = {}) {
+    const minGap = opts.minInBucketGap ?? 0.4;
+    const prefixLen = opts.crossBucketPrefix ?? 60;
+    const rows = trainingRows(labels, insights);
+    const insOf = new Map(insights.map((i) => [i.session, i]));
+    const pairs = [];
+    for (const a of rows) {
+        for (const b of rows) {
+            if (a.session >= b.session)
+                continue;
+            const gap = a.y - b.y;
+            if (gap < minGap)
+                continue;
+            const hi = gap > 0 ? a : b;
+            const lo = gap > 0 ? b : a;
+            const hiIns = insOf.get(hi.session);
+            const loIns = insOf.get(lo.session);
+            if (!hiIns || !loIns)
+                continue;
+            const sameOutcome = hiIns.outcome === loIns.outcome;
+            let ok = false;
+            if (sameOutcome) {
+                ok = true; // in-bucket gold
+            }
+            else {
+                // cross-bucket: only pair completions of the SAME task template
+                // (bench templates share long prefixes) - otherwise they teach
+                // nothing transferable
+                const ta = taskOf(hi.session);
+                const tb = taskOf(lo.session);
+                ok = ta.length >= prefixLen && ta.slice(0, prefixLen) === tb.slice(0, prefixLen);
+            }
+            if (!ok)
+                continue;
+            const srcHi = opts.sources?.get(hi.session);
+            const srcLo = opts.sources?.get(lo.session);
+            pairs.push({
+                prompt: taskOf(hi.session),
+                chosen: answerOf(hi.session),
+                rejected: answerOf(lo.session),
+                chosenSession: hi.session,
+                rejectedSession: lo.session,
+                gap: Number(gap.toFixed(2)),
+                ...(srcHi && srcLo ? { source: srcHi === srcLo ? srcHi : 'mixed' } : {}),
+            });
+        }
+    }
+    return pairs;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hmharness/evolution",
-  "version": "0.14.9",
+  "version": "0.14.11",
   "description": "hmharness evolution subsystem: persistent memory, insight capture, skill library, and the bench that gives evolution its fitness signal. First-class kernel citizen, not a plugin.",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
-    "@hmharness/kernel": "0.9.0"
+    "@hmharness/kernel": "0.9.2"
   },
   "files": [
     "dist"

package/dist/bench.d.ts.v2bak.v2bak

@@ -1,44 +0,0 @@
-export interface BenchCase {
-    name: string;
-    prompt: string;
-    /** All substrings (split on &&) must appear in the output, case-insensitive. */
-    expect: string[];
-    /** Output must equal this string exactly (both trimmed). */
-    expectExact?: string;
-    /** Output must match this regex (whole output, case-sensitive). */
-    expectRegex?: string;
-    /** Substrings that must NOT appear (failure-marker exclusion). */
-    expectNone?: string[];
-    /** At least ONE of these substrings must appear. */
-    expectAny?: string[];
-    /** When true the case runs through the full agent loop with tools. */
-    tools: boolean;
-    /** Holdout cases are excluded from the promotion gate and re-verify after promotion (anti-memorization, GDPevo style). */
-    holdout: boolean;
-    /** Candidate token-cost ceiling as a multiple of the baseline run. */
-    costCap?: number;
-}
-export interface BenchResult {
-    name: string;
-    pass: boolean;
-    detail: string;
-}
-export declare function matchExpect(output: string, expect: string[]): boolean;
-/** Fence convention: when the reply is a fenced block, assertions test the
- *  fence INNER content (day-55 finding: models preserve literals verbatim
- *  inside code fences while normalizing them in prose - the fence is the
- *  reply convention that makes exactness attainable for habit-prone models).
- *  Tolerates a trailing space after the opening fence markers. */
-export declare function fenceInner(output: string): string;
-/** Full structured assertion: every declared mode must hold. */
-export declare function matchCase(output: string, c: Pick<BenchCase, 'expect' | 'expectExact' | 'expectRegex' | 'expectNone' | 'expectAny'>): {
-    pass: boolean;
-    detail: string;
-};
-export declare function listCases(home: string): Promise<BenchCase[]>;
-export declare function runBench(home: string, run: (c: BenchCase) => Promise<string>): Promise<{
-    results: BenchResult[];
-    passRate: number;
-}>;
-/** Starter cases so the evolve gate has a signal from day one. */
-export declare function seedCases(home: string): Promise<string[]>;