tnega 0.1.0 → 0.3.0

package/dist/types/packages/core/src/service.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from './context.js';
+import { symbols, type Any } from './utils.js';
+export declare abstract class Service<out T = never> {
+    [symbols.config]: T;
+    [symbols.filter]: (ctx: Context) => boolean;
+    [symbols.extend]: (props?: Any) => any;
+    [symbols.resolveConfig]: (base?: T, head?: T) => T;
+    protected ctx: Context;
+    static readonly init: symbol;
+    static readonly check: symbol;
+    static readonly config: symbol;
+    static readonly invoke: symbol;
+    static readonly extend: symbol;
+    static readonly tracker: symbol;
+    static readonly resolveConfig: symbol;
+    name: string;
+    constructor(ctx: Context, name?: string);
+    static [Symbol.hasInstance](instance: Any): boolean;
+}

package/dist/types/packages/core/src/utils.d.ts

@@ -0,0 +1,54 @@
+export type Any = any;
+export type AnyFunction = (...args: Any[]) => Any;
+export type Dict<T = Any, K extends PropertyKey = string> = Record<K, T>;
+export declare class DisposableList<T extends WeakKey> {
+    private sn;
+    private map;
+    private weak;
+    get length(): number;
+    push(value: T): () => boolean;
+    unshift(value: T): () => boolean;
+    delete(value: T): boolean;
+    clear(): T[];
+    [Symbol.iterator](): MapIterator<T>;
+}
+export interface Tracker {
+    associate?: string;
+    property?: string;
+    noShadow?: boolean;
+}
+export declare const symbols: {
+    readonly shadow: symbol;
+    readonly caller: symbol;
+    readonly receiver: symbol;
+    readonly original: symbol;
+    readonly metadata: symbol;
+    readonly initHooks: symbol;
+    readonly checkProto: symbol;
+    readonly effect: symbol;
+    readonly filter: symbol;
+    readonly isolate: symbol;
+    readonly intercept: symbol;
+    readonly init: symbol;
+    readonly check: symbol;
+    readonly config: symbol;
+    readonly invoke: symbol;
+    readonly extend: symbol;
+    readonly tracker: symbol;
+    readonly resolveConfig: symbol;
+};
+export declare function isConstructor(func: Any): func is new (...args: Any[]) => Any;
+export declare function isObject(value: Any): value is object;
+export declare function isNullable(value: Any): boolean;
+export declare function joinPrototype(proto1: object, proto2: object): object;
+export declare function getPropertyDescriptor(target: Any, prop: string | symbol): TypedPropertyDescriptor<any> | undefined;
+export declare function getTraceable<T>(ctx: Any, value: T): T;
+export declare function withProps(target: Any, props?: Any): any;
+export declare function createCallable(name: string, proto: object, tracker: Tracker): any;
+interface StackInfo {
+    offset: number;
+    error: Error;
+}
+export declare function composeError<T>(callback: (info: StackInfo) => T, getOuterStack?: () => string[]): T;
+export declare function buildOuterStack(offset?: number): () => string[];
+export {};

package/dist/types/packages/eval/src/codingRuntime.d.ts

@@ -0,0 +1,18 @@
+import { type AgentLoop } from "../../agent/src/index.js";
+import { Context } from "../../core/src/index.js";
+import { type ToolPolicy } from "../../tools/src/index.js";
+import type { CodingEvalConfig } from './types.js';
+export interface CodingEvalRuntimeOptions {
+    cwd: string;
+    sessionFile: string;
+    config: CodingEvalConfig;
+    toolPolicy: ToolPolicy;
+    allowShell?: boolean;
+    allowNetwork?: boolean;
+}
+export interface CodingEvalRuntime {
+    root: Context;
+    loop: AgentLoop;
+    dispose(): Promise<void>;
+}
+export declare function createCodingEvalRuntime(options: CodingEvalRuntimeOptions): Promise<CodingEvalRuntime>;

package/dist/types/packages/eval/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './strategies.js';
+export * from './service.js';
+export * from './types.js';
+export * from './utils.js';
+export declare const name = "index.js";

package/dist/types/packages/eval/src/policy.d.ts

@@ -0,0 +1,8 @@
+import type { ToolPolicy } from "../../tools/src/index.js";
+import type { TaskPermissions } from './types.js';
+export interface EvalToolPolicyOptions {
+    workspace: string;
+    permissions?: TaskPermissions;
+    maxOutputBytes?: number;
+}
+export declare function createEvalToolPolicy(options: EvalToolPolicyOptions): ToolPolicy;

package/dist/types/packages/eval/src/runner.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from "../../core/src/index.js";
+import { type EvalRun, type EvalRunOptions, type RunBudget } from './types.js';
+import type { StrategyRegistry } from './strategies.js';
+export declare class EvalRunner {
+    private ctx;
+    private strategies;
+    private defaultBudget;
+    private outputDir;
+    constructor(ctx: Context, strategies: StrategyRegistry, defaultBudget?: RunBudget, outputDir?: string);
+    run(options: EvalRunOptions): Promise<EvalRun>;
+    private _createTaskScope;
+    private _armTimeout;
+    private _runTask;
+    private _runCodingTask;
+    private _runCheck;
+    private _aggregateTrials;
+    private _fixtureRoot;
+    private _loop;
+    private _cacheKey;
+    private _sessionFile;
+    private _tokens;
+    private _cost;
+    private _exceeded;
+    private _summarize;
+    private _abort;
+    private _loadRun;
+    private _loadCachedEvidence;
+    private _saveCachedEvidence;
+    private _message;
+    private _errorPayload;
+}

package/dist/types/packages/eval/src/service.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from "../../core/src/index.js";
+import { type StrategyRegistry } from './strategies.js';
+import { type CompareResult, type EvalPluginConfig, type EvalRun, type EvalRunOptions, type EvalStrategyDefinition } from './types.js';
+export declare class EvalService {
+    private ctx;
+    private config;
+    readonly strategies: StrategyRegistry;
+    constructor(ctx: Context, config?: EvalPluginConfig);
+    register(definition: EvalStrategyDefinition): () => void;
+    unregister(name: string): boolean;
+    getStrategy(name: string): import("./types.js").EvalStrategy | undefined;
+    listStrategies(): string[];
+    run(options: EvalRunOptions): Promise<EvalRun>;
+    loadRun(input: string | EvalRun): Promise<EvalRun>;
+    saveRun(run: EvalRun, file?: string): Promise<string>;
+    compare(base: string | EvalRun, head: string | EvalRun): Promise<CompareResult>;
+    private _taskVerdict;
+    private _score;
+}
+export declare const evalPlugin: {
+    name: string;
+    apply: (ctx: Context, config?: EvalPluginConfig) => () => void;
+};

package/dist/types/packages/eval/src/strategies.d.ts

@@ -0,0 +1,58 @@
+import { type EvalStrategy, type EvalStrategyDefinition, type Evidence, type Task } from './types.js';
+export interface AssertStrategyOptions {
+    /** Compare exact output when no task assertion is present. */
+    expect?: string | string[];
+    /** Treat a failing task as error instead of fail. */
+    strictFiles?: boolean;
+}
+export interface JudgeStrategyOptions {
+    judge?: (task: Task, evidence: Evidence) => number | Promise<number>;
+    /** Threshold above which the verdict passes (default 0.5). */
+    passThreshold?: number;
+}
+export interface RegressionStrategyOptions {
+    maxDegradation?: number;
+    requireBaseline?: boolean;
+}
+export interface AllStrategyOptions {
+    strategies?: string[];
+}
+export interface WeightedStrategyOptions {
+    strategies?: Array<{
+        name: string;
+        weight: number;
+    }>;
+    passThreshold?: number;
+}
+export interface GateStrategyOptions {
+    required?: string[];
+    thresholds?: Record<string, number>;
+    minScore?: number;
+}
+export interface CheckStrategyOptions {
+    /** Minimum pass rate over trials, default 1. */
+    passRate?: number;
+}
+export interface TraceStrategyOptions {
+    /** Minimum aggregate trace score, default 0.7. */
+    passThreshold?: number;
+}
+export declare function assertStrategy(options?: AssertStrategyOptions): EvalStrategy;
+export declare function recordJudgeOutput(key: string, score: number): void;
+export declare function recordedJudgeOutput(key: string): number | undefined;
+export declare function judgeStrategy(options?: JudgeStrategyOptions): EvalStrategy;
+export declare function regressionStrategy(options?: RegressionStrategyOptions): EvalStrategy;
+export declare function allStrategy(options?: AllStrategyOptions): EvalStrategy;
+export declare function weightedStrategy(options?: WeightedStrategyOptions): EvalStrategy;
+export declare function gateStrategy(options?: GateStrategyOptions): EvalStrategy;
+export declare function checkStrategy(options?: CheckStrategyOptions): EvalStrategy;
+export declare function traceStrategy(options?: TraceStrategyOptions): EvalStrategy;
+export interface StrategyRegistry {
+    register(definition: EvalStrategyDefinition): () => void;
+    unregister(name: string): boolean;
+    get(name: string): EvalStrategy | undefined;
+    has(name: string): boolean;
+    names(): string[];
+}
+export declare function createStrategyRegistry(initial?: EvalStrategyDefinition[]): StrategyRegistry;
+export declare function defaultStrategyDefinitions(): EvalStrategyDefinition[];

package/dist/types/packages/eval/src/trace.d.ts

@@ -0,0 +1,7 @@
+import type { SessionEvent } from "../../session/src/index.js";
+import type { TrialTrace } from './types.js';
+export declare function readTrace(file: string): Promise<SessionEvent[]>;
+export declare function deriveTraceMetrics(file: string, startedAt: number, endedAt: number, usage?: {
+    tokens?: number;
+    cost?: number;
+}): Promise<TrialTrace>;

package/dist/types/packages/eval/src/types.d.ts

@@ -0,0 +1,281 @@
+import type { Context, Plugin } from "../../core/src/index.js";
+import type { AgentRunResult, LLMAdapter } from "../../agent/src/index.js";
+import type { ModelMessage } from "../../session/src/index.js";
+export type VerdictStatus = 'pass' | 'fail' | 'skip' | 'error';
+export interface EvalWorkspaceFixture {
+    /** Template directory relative to the tasks file. */
+    root?: string;
+    /** Explicit file entries; use content or from. */
+    files?: Array<{
+        path: string;
+        content?: string;
+        from?: string;
+    }>;
+}
+export interface EvalShellPolicy {
+    enabled: boolean;
+    /** Allowed command prefixes, e.g. ["pytest", "pip install", "node"]. */
+    allow?: string[];
+    /** Denied command prefixes, e.g. ["rm", "taskkill"]. */
+    deny?: string[];
+}
+export interface TaskPermissions {
+    /** Tool whitelist; defaults to the safe builtin set. */
+    tools?: string[];
+    /** Shell policy; disabled by default. */
+    shell?: EvalShellPolicy;
+    /** Network tools; false by default. */
+    network?: boolean;
+    /** Skill tools; follows candidate config by default. */
+    skills?: boolean;
+    /** MCP is always false during eval. */
+    mcp?: boolean;
+}
+export interface TaskAssertion {
+    /** Exact output match, or a list of required substrings. */
+    expect?: string | string[];
+    /** Files that must exist, or a function checking files. */
+    files?: string[] | ((evidence: Evidence) => boolean | Promise<boolean>);
+    /** Arbitrary predicate over evidence and task. */
+    check?: (evidence: Evidence, task: Task) => boolean | Promise<boolean>;
+}
+export interface TaskBudget {
+    maxTurns?: number;
+    maxSteps?: number;
+    maxTimeMs?: number;
+    maxTokens?: number;
+    maxCost?: number;
+}
+export interface Task {
+    id: string;
+    name?: string;
+    description?: string;
+    input?: unknown;
+    inputText?: string;
+    messages?: ModelMessage[];
+    assertion?: TaskAssertion;
+    strategies?: string[];
+    budget?: TaskBudget;
+    artifacts?: Record<string, unknown>;
+    fixture?: EvalWorkspaceFixture;
+    /** Setup command or hook, run inside the workspace before the agent. */
+    setup?: string | ((workspace: string) => void | Promise<void>);
+    /** Success check: command (exit 0) or predicate. */
+    check?: string | ((evidence: Evidence, workspace: string) => boolean | Promise<boolean>);
+    /** Teardown command or hook, run after the trial. */
+    teardown?: string | ((workspace: string) => void | Promise<void>);
+    /** Default 3; must be >= 1. */
+    trials?: number;
+    permissions?: TaskPermissions;
+    /** Default 'train'. */
+    split?: 'train' | 'val';
+}
+export interface CandidateMetadata {
+    name: string;
+    version?: string;
+    config?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}
+export interface CandidatePreset {
+    plugin: Plugin;
+    name: string;
+    version?: string;
+    config?: Record<string, unknown>;
+    model?: Record<string, unknown>;
+}
+export interface TrialTraceMetrics {
+    steps: number;
+    turns: number;
+    toolCalls: number;
+    toolErrors: number;
+    invalidToolCalls: number;
+    retries: number;
+    tokens: number;
+    cost: number;
+    recoveredAfterError: boolean;
+}
+export interface TrialTrace {
+    file: string;
+    startedAt: number;
+    endedAt: number;
+    durationMs: number;
+    metrics: TrialTraceMetrics;
+}
+export interface TrialEvidence {
+    trial: number;
+    verdicts: Verdict[];
+    trace: TrialTrace;
+    agentResult?: AgentRunResult;
+    artifacts: Record<string, unknown>;
+}
+export interface Evidence {
+    task: Task;
+    agentResult?: AgentRunResult;
+    messages: ModelMessage[];
+    artifacts: Record<string, unknown>;
+    strategyOutputs: Record<string, unknown>;
+    trials?: TrialEvidence[];
+}
+export interface Verdict {
+    taskId: string;
+    strategy: string;
+    status: VerdictStatus;
+    score: number;
+    reason?: string;
+    output?: unknown;
+    meta?: Record<string, unknown>;
+}
+export interface RunBudget {
+    maxTurns?: number;
+    maxTokens?: number;
+    maxCost?: number;
+    maxTimeMs?: number;
+}
+export interface BudgetUsage {
+    turns: number;
+    tokens: number;
+    cost: number;
+    timeMs: number;
+}
+export interface EvalRun {
+    id: string;
+    createdAt: number;
+    candidate: CandidateMetadata;
+    taskIds: string[];
+    verdicts: Verdict[];
+    trialSummaries?: TrialSummary[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+        errors: number;
+        score: number;
+        budget: BudgetUsage;
+    };
+    cacheHits: number;
+    cacheKey?: string;
+    modelConfigHash?: string;
+    baselineRunId?: string;
+    aborted: boolean;
+    abortedReason?: string;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+}
+export interface TrialSummary {
+    taskId: string;
+    trials: number;
+    passed: number;
+    passRate: number;
+    scoreMean: number;
+    scoreMedian: number;
+    scoreStddev: number;
+    costMean: number;
+    stepsMean: number;
+}
+export interface CodingEvalAgentConfig {
+    systemPrompt?: string;
+    maxTurns?: number;
+    maxSteps?: number;
+}
+export interface CodingEvalCodingConfig {
+    skills?: boolean;
+    planTools?: boolean;
+    mcp?: boolean;
+    planPrompt?: string;
+}
+export interface CodingEvalConfig {
+    llm: LLMAdapter;
+    agent?: CodingEvalAgentConfig;
+    coding?: CodingEvalCodingConfig;
+}
+export interface EvalRunOptions {
+    candidate: CandidatePreset;
+    tasks: readonly Task[];
+    strategyNames?: string[];
+    baselineRunId?: string;
+    budget?: RunBudget;
+    cache?: boolean;
+    cacheDir?: string;
+    outputFile?: string;
+    runCandidate?: (ctx: Context, task: Task) => Promise<AgentRunResult>;
+    coding?: CodingEvalConfig;
+}
+export interface StrategyContext {
+    ctx: Context;
+    run: Pick<EvalRun, 'id' | 'candidate'>;
+    baseline?: EvalRun;
+}
+export interface EvalStrategy {
+    name: string;
+    evaluate(ctx: StrategyContext, task: Task, evidence: Evidence): Verdict | Promise<Verdict>;
+    dispose?(): void | Promise<void>;
+}
+export interface EvalStrategyDefinition {
+    name: string;
+    evaluate: EvalStrategy['evaluate'];
+}
+export interface CompareResult {
+    base: EvalRun;
+    head: EvalRun;
+    summary: {
+        baseScore: number;
+        headScore: number;
+        delta: number;
+        passed: number;
+        failed: number;
+        regressions: string[];
+        improvements: string[];
+    };
+    taskResults: Array<{
+        taskId: string;
+        base: Verdict | undefined;
+        head: Verdict | undefined;
+        delta: number;
+        changed: boolean;
+    }>;
+}
+export interface EvalPluginConfig {
+    strategyNames?: string[];
+    defaultBudget?: RunBudget;
+    outputDir?: string;
+    llmJudge?: (task: Task, evidence: Evidence) => Promise<number> | number;
+    gate?: {
+        required?: string[];
+        thresholds?: Record<string, number>;
+        minScore?: number;
+    };
+}
+export interface EvalStartEvent {
+    runId: string;
+    candidate: CandidateMetadata;
+    taskIds: string[];
+    budget: RunBudget;
+}
+export interface EvalTaskStartEvent {
+    runId: string;
+    task: Task;
+    scope: Context;
+}
+export interface EvalTaskEndEvent {
+    runId: string;
+    task: Task;
+    evidence: Evidence;
+    durationMs: number;
+    fromCache: boolean;
+}
+export interface EvalVerdictEvent {
+    runId: string;
+    taskId: string;
+    verdict: Verdict;
+}
+export interface EvalRunEndEvent {
+    run: EvalRun;
+}
+export interface EvalAbortEvent {
+    runId: string;
+    taskId?: string;
+    reason: string;
+}

package/dist/types/packages/eval/src/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function stableStringify(value: unknown): string;
+export declare function hashJson(value: unknown): string;
+export declare function clone<T>(value: T): T;
+export declare function saveJson(file: string, value: unknown): Promise<void>;
+export declare function loadJson<T>(file: string): Promise<T>;

package/dist/types/packages/eval/src/workspace.d.ts

@@ -0,0 +1,17 @@
+import type { Task } from './types.js';
+export interface TaskWorkspace {
+    dir: string;
+    dispose(): Promise<void>;
+}
+export interface WorkspaceCommandOptions {
+    timeoutMs?: number;
+    maxBuffer?: number;
+    signal?: AbortSignal;
+}
+export interface WorkspaceCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function createTaskWorkspace(task: Task, fixtureRoot?: string): Promise<TaskWorkspace>;
+export declare function runWorkspaceCommand(cwd: string, command: string, options?: WorkspaceCommandOptions): Promise<WorkspaceCommandResult>;

package/dist/types/packages/evolve/src/diagnose.d.ts

@@ -0,0 +1,9 @@
+import type { EvalRun } from "../../eval/src/index.js";
+import { type Candidate, type CandidateSnapshot, type Diagnosis, type ProposalContext, type ProposeRule } from './types.js';
+export declare function emptyDiagnosis(): Diagnosis;
+export declare function diagnose(run: EvalRun): Diagnosis;
+export declare function candidateKey(candidate: Candidate): string;
+export declare function proposeCandidates(context: ProposalContext, rules: readonly ProposeRule[]): Promise<Candidate[]>;
+export declare function proposalContext(baseline: EvalRun | undefined, history: readonly import('./types.js').ExperimentNode[], rules: readonly ProposeRule[], iteration?: number, diagnosis?: Diagnosis): ProposalContext;
+export declare function toCandidateSnapshot(candidate: Candidate): CandidateSnapshot;
+export declare function toCandidatePreset(candidate: Candidate): import("../../eval/src/index.js").CandidatePreset;

package/dist/types/packages/evolve/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './diagnose.js';
+export * from './llm.js';
+export * from './log.js';
+export * from './select.js';
+export * from './service.js';
+export * from './types.js';
+export declare const name = "index.js";

package/dist/types/packages/evolve/src/llm.d.ts

@@ -0,0 +1,39 @@
+import type { LLMAdapter } from "../../agent/src/index.js";
+import type { Candidate, CandidateMutation, ProposeRule } from './types.js';
+export interface LlmCandidateConfig {
+    system?: string;
+    maxTurns?: number;
+    maxSteps?: number;
+}
+export interface LlmCandidateOptions {
+    name: string;
+    version?: string;
+    system?: string;
+    adapter: LLMAdapter;
+    maxTurns?: number;
+    maxSteps?: number;
+    model?: Record<string, unknown>;
+    mutation?: CandidateMutation;
+    rationale?: string;
+}
+export interface LlmProposal {
+    name: string;
+    system: string;
+    rationale: string;
+    mutationDescription: string;
+}
+export interface LlmProposeRuleOptions {
+    adapter: LLMAdapter;
+    maxTurns?: number;
+    maxSteps?: number;
+    model?: Record<string, unknown>;
+    ruleId?: string;
+    parse?: (content: string) => LlmProposal | Promise<LlmProposal>;
+}
+export declare class LlmProposalError extends Error {
+    name: string;
+}
+export declare function withSystemPrompt(adapter: LLMAdapter, system: string): LLMAdapter;
+export declare function llmCandidate(options: LlmCandidateOptions): Candidate;
+export declare function createLlmProposeRule(options: LlmProposeRuleOptions): ProposeRule;
+export declare function parseLlmProposal(content: string): LlmProposal;

package/dist/types/packages/evolve/src/log.d.ts

@@ -0,0 +1,26 @@
+import type { ExperimentLogData, ExperimentNode, ExperimentReplay } from './types.js';
+export declare class ExperimentLog {
+    readonly file: string;
+    private _data;
+    constructor(file: string, data?: ExperimentLogData);
+    static open(file: string): Promise<ExperimentLog>;
+    get id(): string;
+    get baselineId(): string | undefined;
+    get baseline(): ExperimentNode | undefined;
+    get size(): number;
+    nodes(): ExperimentNode[];
+    get(id: string): ExperimentNode | undefined;
+    roots(): ExperimentNode[];
+    children(parentId: string): ExperimentNode[];
+    lineage(id: string): ExperimentNode[];
+    add(node: ExperimentNode): Promise<void>;
+    update(node: ExperimentNode): Promise<void>;
+    setBaseline(nodeId: string): Promise<void>;
+    fork(options?: {
+        parentId?: string;
+        file?: string;
+    }): Promise<ExperimentLog>;
+    replay(nodeId: string): Promise<ExperimentReplay>;
+    save(): Promise<void>;
+    private _empty;
+}

package/dist/types/packages/evolve/src/select.d.ts

@@ -0,0 +1,3 @@
+import type { CompareResult, EvalRun } from "../../eval/src/index.js";
+import type { ExperimentNode, GateCheck, SelectionPolicy } from './types.js';
+export declare function evaluateGate(node: ExperimentNode, baseline: EvalRun | undefined, compare: CompareResult | undefined, policy?: SelectionPolicy): Promise<GateCheck[]>;

package/dist/types/packages/evolve/src/service.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from "../../core/src/index.js";
+import type { EvalRunOptions } from "../../eval/src/index.js";
+import { ExperimentLog } from './log.js';
+import type { Candidate, EvolveOptions, EvolvePluginConfig, EvolveStepOptions, EvolveStepResult, ExperimentNode, ProposalContext } from './types.js';
+export declare class EvolveService {
+    private ctx;
+    private config;
+    private _log;
+    private _ready;
+    constructor(ctx: Context, config?: EvolvePluginConfig);
+    init(): Promise<ExperimentLog>;
+    propose(options?: Partial<ProposalContext>): Promise<Candidate[]>;
+    evaluate(candidate: Candidate, options?: Partial<EvalRunOptions>): Promise<ExperimentNode>;
+    decide(nodeId: string, approved?: boolean): Promise<ExperimentNode>;
+    approve(nodeId: string, approved?: boolean): Promise<ExperimentNode>;
+    step(options?: EvolveStepOptions): Promise<EvolveStepResult>;
+    evolve(options?: EvolveOptions): Promise<EvolveStepResult>;
+    baseline(): Promise<ExperimentNode | undefined>;
+    history(): Promise<ExperimentNode[]>;
+    replay(nodeId: string): Promise<import("./types.js").ExperimentReplay>;
+    loadLog(file?: string): Promise<ExperimentLog>;
+    private _eval;
+    private _nodeByRunId;
+    private _logFile;
+}
+export declare const evolvePlugin: {
+    name: string;
+    apply: (ctx: Context, config?: EvolvePluginConfig) => Promise<() => void>;
+};