@tangle-network/agent-eval 0.93.0 → 0.95.0

package/dist/client.d.ts

@@ -0,0 +1,77 @@
+import type { CheckResult, ProductClientConfig, TestResult } from './types';
+export declare class ProductClient {
+    private baseUrl;
+    private routes;
+    private cookies;
+    private timeoutMs;
+    constructor(config: ProductClientConfig);
+    private route;
+    /**
+     * Single HTTP boundary for every JSON request. Aborts after `timeoutMs`,
+     * checks `res.ok` BEFORE parsing, and throws `${method} ${path} failed:
+     * HTTP ${status} — ${body}` on a non-ok response so a 4xx/5xx error body
+     * can never be parsed as a success shape. Callers inspect the resolved
+     * value only after a successful return.
+     */
+    private request;
+    /**
+     * Read a required collection field. A missing/non-array field is a contract
+     * violation (wrong route, drift, partial body) — surface it loud instead of
+     * masking it as a healthy empty set. A genuinely empty `[]` passes through.
+     */
+    private requireArray;
+    signup(name: string, email: string, password: string): Promise<{
+        userId: string;
+    }>;
+    login(email: string, password: string): Promise<void>;
+    createWorkspace(name: string, type?: string): Promise<string>;
+    createThread(workspaceId: string): Promise<string>;
+    chat(workspaceId: string, threadId: string, content: string, _opts?: {
+        blockPatterns?: RegExp[];
+    }): Promise<{
+        text: string;
+        blocks: {
+            type: string;
+            title: string;
+        }[];
+    }>;
+    getTasks(workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        status: string;
+        priority: string;
+    }[]>;
+    getEvents(workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        type: string;
+    }[]>;
+    getApprovals(workspaceId: string): Promise<{
+        id: string;
+        title: string;
+        status: string;
+        type: string;
+    }[]>;
+    getVaultTree(workspaceId: string): Promise<string[]>;
+    approveAction(workspaceId: string, id: string): Promise<void>;
+    rejectAction(workspaceId: string, id: string, reason: string): Promise<void>;
+    getGenerations(workspaceId: string): Promise<{
+        id: string;
+        type: string;
+        prompt: string;
+    }[]>;
+    /** Generic GET for custom routes */
+    get(path: string): Promise<Record<string, unknown>>;
+    /** Generic POST for custom routes */
+    post(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Generic PATCH for custom routes */
+    patch(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+/**
+ * Run a full e2e workflow test against a live product.
+ *
+ * The `workflow` callback receives a ProductClient and returns CheckResults.
+ * This is the generic harness — each agent defines its own workflow steps.
+ */
+export declare function runE2EWorkflow(client: ProductClient, name: string, workflow: (client: ProductClient) => Promise<CheckResult[]>): Promise<TestResult>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

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

package/dist/client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.test.d.ts.map

package/dist/client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../src/client.test.ts"],"names":[],"mappings":""}

package/dist/command-runner.d.ts

@@ -0,0 +1,74 @@
+/**
+ * CommandRunner — abstract subprocess execution surface.
+ *
+ * Layers in a {@link MultiLayerVerifier} that need to invoke external
+ * tools (compilers, test runners, package managers) call out via this
+ * interface rather than directly using `child_process`. Two reasons:
+ *
+ *   1. **Sandbox interchangeability.** A run that targets a sandbox box
+ *      (via SDK-specific Box.exec) and a run that targets the host both
+ *      satisfy this same contract. The harness doesn't care which.
+ *   2. **Testability.** Tests inject a fake runner and assert on calls
+ *      without spawning real subprocesses.
+ *
+ * agent-eval ships only the local implementation (host-process). Sandbox
+ * implementations live with their consumer because they depend on
+ * SDK-specific Box / Sandbox types that don't belong in this package.
+ */
+export interface RunCommandInput {
+    /** Executable name, looked up via PATH unless absolute. */
+    cmd: string;
+    /** Argument vector, NOT shell-interpolated. Each element passed to argv. */
+    argv: string[];
+    /** Working directory. Defaults to runner's notion of cwd if omitted. */
+    cwd?: string;
+    /**
+     * Wall-clock cap in ms. The runner SHOULD return `timedOut: true` when
+     * exceeded; callers MAY treat status null + timedOut as "killed."
+     */
+    capMs?: number;
+    /** Env overrides merged on top of the runner's base environment. */
+    env?: Record<string, string>;
+    /** Optional stdin payload. */
+    stdin?: string;
+}
+export interface RunCommandResult {
+    /** Exit code, or null when the process couldn't start / was killed. */
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    timedOut: boolean;
+    /** Non-fatal runner-side error (binary missing, signal, etc.). */
+    runnerError?: string;
+}
+export interface DirEntry {
+    name: string;
+    isDirectory: boolean;
+    isFile: boolean;
+    /** File size in bytes. `null` for directories (not stat'd). */
+    sizeBytes: number | null;
+}
+export interface CommandRunner {
+    /** Identifier for telemetry + logs. Open-ended literal-union for new runners. */
+    readonly name: string;
+    /** Execute a command in the runner's environment. */
+    run(input: RunCommandInput): Promise<RunCommandResult>;
+    /** True iff `<name>` resolves on the runner's PATH. */
+    hasBin(name: string): Promise<boolean>;
+    /** True iff the given path exists in the runner's filesystem. */
+    fileExists(path: string): Promise<boolean>;
+    /** Read a file. Returns `null` if missing or unreadable. */
+    readFile(path: string): Promise<string | null>;
+    /** List a directory. Returns `[]` if unreadable / missing. */
+    readDir(path: string): Promise<DirEntry[]>;
+}
+/**
+ * Host-process runner. Uses node:child_process spawnSync (synchronous
+ * under the hood — wrapped in a Promise to satisfy the interface). For
+ * very long-running commands consider an async-spawn variant; this
+ * shape matches VB's existing behavior and is fine for build/test/lint
+ * subprocesses that finish in seconds-to-minutes.
+ */
+export declare const localCommandRunner: CommandRunner;
+//# sourceMappingURL=command-runner.d.ts.map

package/dist/command-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-runner.d.ts","sourceRoot":"","sources":["../src/command-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAeH,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAA;IACX,4EAA4E;IAC5E,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,wEAAwE;IACxE,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;IACjB,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,OAAO,CAAA;IACpB,MAAM,EAAE,OAAO,CAAA;IACf,+DAA+D;IAC/D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,qDAAqD;IACrD,GAAG,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACtD,uDAAuD;IACvD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACtC,iEAAiE;IACjE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC1C,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAC9C,8DAA8D;IAC9D,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAA;CAC3C;AAID;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,aA0EhC,CAAA"}

package/dist/command-runner.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=command-runner.test.d.ts.map

package/dist/command-runner.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-runner.test.d.ts","sourceRoot":"","sources":["../src/command-runner.test.ts"],"names":[],"mappings":""}

package/dist/completion-verifier.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Completion verifier — the task-completion oracle.
+ *
+ * Answers the only eval question that is not a proxy: did the agent actually
+ * COMPLETE the task — produce every required deliverable, persisted and
+ * correct — rather than describe what should be done. A fluent transcript
+ * that never produces the artifact scores zero here.
+ *
+ * Per requirement, a two-stage check:
+ *   1. Structural — a produced item (vault artifact / approved proposal /
+ *      tool call) of the right kind is matched against the requirement and
+ *      carries non-empty content. Deterministic; no LLM.
+ *   2. Correctness — only if structurally present AND the matched item
+ *      carries content, one targeted check decides whether that item
+ *      actually fulfils the requirement. A hallucinated artifact fails here;
+ *      an absent one already failed stage 1.
+ *
+ * `completionRate` is satisfied / total. Quality dimensions are meaningless
+ * on an incomplete task — callers gate on `fullyComplete` / `completionRate`
+ * before scoring quality.
+ */
+import type { TCloud } from '@tangle-network/tcloud';
+import type { Artifact } from './artifact-validator';
+import type { DefaultVerdict } from './verdict';
+/** What kind of produced state can satisfy a requirement structurally. */
+export type SatisfiedBy = 'artifact' | 'proposal' | 'tool-call' | 'any';
+export interface CompletionRequirement {
+    /** Stable id from the task gold (e.g. a persona's `expected_requirements[].req_id`). */
+    reqId: string;
+    /** Human-readable description of the required deliverable. */
+    title: string;
+    /** Optional kind/category hint, matched against a produced item's kind. */
+    category?: string;
+    /** What produced state satisfies this requirement. Defaults to 'any'. */
+    satisfiedBy?: SatisfiedBy;
+}
+export interface TaskGold {
+    taskId: string;
+    requirements: CompletionRequirement[];
+}
+export interface ProducedProposal {
+    id: string;
+    title: string;
+    status: 'pending' | 'approved' | 'rejected';
+    /** Optional persisted body — when present, enables a correctness check. */
+    content?: string;
+}
+/** Everything observable about what a run actually produced. */
+export interface ProducedState {
+    /** Persisted vault artifacts. Reuses the shared `Artifact` shape. */
+    artifacts: Artifact[];
+    /** Proposals / filings the agent created. */
+    proposals: ProducedProposal[];
+    /** Names of tools the agent invoked. */
+    toolCalls: string[];
+}
+export interface RequirementCheck {
+    reqId: string;
+    title: string;
+    /** A produced item of the right kind matched the requirement, non-empty. */
+    structurallyPresent: boolean;
+    /**
+     * Whether the matched item actually fulfils the requirement. `null` when
+     * not structurally present, or when the matched item carries no content
+     * to assess.
+     */
+    correct: boolean | null;
+    /** structurallyPresent && correct !== false. */
+    satisfied: boolean;
+    /** Human-readable evidence for the verdict. */
+    evidence: string[];
+}
+/** Extends the substrate verdict spine: `valid` = `fullyComplete` and
+ *  `score` = `completionRate` — derived in `completionVerdict()`, the one
+ *  place those equalities hold by construction. */
+export interface CompletionVerdict extends DefaultVerdict {
+    taskId: string;
+    requirements: RequirementCheck[];
+    /** satisfied / total requirements. */
+    completionRate: number;
+    /** Every requirement satisfied. */
+    fullyComplete: boolean;
+}
+/**
+ * Construct a `CompletionVerdict` from the per-requirement checks, deriving
+ * `completionRate` / `fullyComplete` and the spine fields (`valid` =
+ * `fullyComplete`, `score` = `completionRate`) in one place. Throws on zero
+ * requirements — a verdict over nothing is a misconfiguration, mirroring
+ * `verifyCompletion`'s gold-spec guard.
+ */
+export declare function completionVerdict(input: {
+    taskId: string;
+    requirements: RequirementCheck[];
+}): CompletionVerdict;
+/**
+ * Decides whether a produced item's content actually fulfils a requirement.
+ * Injected so the structural verifier stays pure and unit-testable; the
+ * production implementation is `createLlmCorrectnessChecker`.
+ */
+export type CorrectnessChecker = (requirement: CompletionRequirement, content: string) => Promise<{
+    correct: boolean;
+    reason: string;
+}>;
+/**
+ * Verify whether a run completed the task. `checkCorrectness` is injected —
+ * `createLlmCorrectnessChecker` for production, a deterministic stub in tests.
+ *
+ * Throws on a gold spec with no requirements: an eval task that requires
+ * nothing is a misconfiguration, not a vacuously-complete task.
+ */
+export declare function verifyCompletion(gold: TaskGold, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<CompletionVerdict>;
+export interface LlmCorrectnessCheckerOpts {
+    model?: string;
+    /** Max chars of artifact content sent to the checker. */
+    maxContentChars?: number;
+}
+/** Parse the correctness checker's model response. Fails loud on a bad shape. */
+export declare function parseCorrectnessResponse(raw: string): {
+    correct: boolean;
+    reason: string;
+};
+/**
+ * Production `CorrectnessChecker` — one LLM call per matched artifact,
+ * deterministic (temperature 0), structured JSON out. Judges fulfilment
+ * only: a plan, a gesture, or a description of what should be done does not
+ * fulfil a requirement — the artifact must BE the deliverable.
+ */
+export declare function createLlmCorrectnessChecker(tc: TCloud, opts?: LlmCorrectnessCheckerOpts): CorrectnessChecker;
+/**
+ * Deterministic `CorrectnessChecker` — the no-LLM counterpart to
+ * `createLlmCorrectnessChecker`. A produced item fulfils a requirement when its
+ * content is substantive (≥ `minContentLength` chars) AND recalls ≥ `minRecall`
+ * of the requirement title's significant tokens. No network.
+ *
+ * Polarity-blind: token recall credits a negation that contains the
+ * requirement's tokens ("I will NOT produce the comparison" recalls every token
+ * of "produce the comparison"). The structural match stage is ALSO lexical, so
+ * pairing the two collapses to a single gameable gate. Use this only as an
+ * opt-in structural pre-filter or for tasks whose requirements have no polarity
+ * to invert; for produced-state grading the correctness checker MUST be semantic
+ * (`createLlmCorrectnessChecker`). See the anti-game fixtures in the test suite.
+ */
+export declare function createTokenRecallChecker(opts?: {
+    minRecall?: number;
+    minContentLength?: number;
+}): CorrectnessChecker;
+//# sourceMappingURL=completion-verifier.d.ts.map

package/dist/completion-verifier.d.ts.map

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

package/dist/completion-verifier.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The completion verifier is the eval's anti-proxy guarantee: a score only
+ * means something if this oracle confirms the task was actually done. These
+ * tests pin the regressions that would silently re-inflate scores —
+ * structurally-absent deliverables passing, hallucinated artifacts passing,
+ * pending work counting as complete.
+ */
+export {};
+//# sourceMappingURL=completion-verifier.test.d.ts.map

package/dist/completion-verifier.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-verifier.test.d.ts","sourceRoot":"","sources":["../src/completion-verifier.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/concurrency.d.ts

@@ -0,0 +1,23 @@
+/**
+ * concurrency — small primitives the evolution loop needs.
+ *
+ * `Mutex` is a zero-dep async lock with FIFO fairness. The evolution loop
+ * uses it to serialise checkout/build/commit sequences inside a single
+ * pool slot, and to gate concurrent JSONL writers (see
+ * `lockedJsonlReferenceReplayStore`).
+ *
+ * Deliberately minimal — no priority queue, no timeouts. If you need
+ * those, swap to `async-mutex` at the call site.
+ */
+export declare class Mutex {
+    private locked;
+    private readonly waiters;
+    acquire(): Promise<() => void>;
+    private release;
+    runExclusive<T>(fn: () => Promise<T> | T): Promise<T>;
+    /** True iff someone holds the lock right now. Diagnostics only. */
+    get isLocked(): boolean;
+    /** Pending waiter count. Diagnostics only. */
+    get pending(): number;
+}
+//# sourceMappingURL=concurrency.d.ts.map

package/dist/concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrency.d.ts","sourceRoot":"","sources":["../src/concurrency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAE1C,OAAO,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC;IAYpC,OAAO,CAAC,OAAO;IAST,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAS3D,mEAAmE;IACnE,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,8CAA8C;IAC9C,IAAI,OAAO,IAAI,MAAM,CAEpB;CACF"}

package/dist/contamination-guard.d.ts

@@ -0,0 +1,81 @@
+/**
+ * ContaminationGuard — ensures held-out scenarios don't leak into
+ * training/prompt paths, and flags model memorization.
+ *
+ * Three probes:
+ *   1. `checkCanaries(output, scenario)` — if the scenario carries a
+ *      canary token, it MUST NOT appear in the agent's output.
+ *      Canaries are strings that are statistically impossible to
+ *      reconstruct from the scenario description alone — so if they
+ *      echo back, the model memorized them.
+ *   2. `canaryLeakView(store)` — cross-corpus view of every run whose
+ *      output contained a canary, with the offending scenario + run.
+ *   3. `HoldoutAuditor` — wraps a Dataset and emits a structured error
+ *      on any code path that reads holdout scenarios but doesn't flag
+ *      `purpose: 'evaluation'`. Keeps engineers honest.
+ */
+import type { DatasetScenario } from './dataset';
+import type { TraceStore } from './trace/store';
+export interface CanaryLeak {
+    scenarioId: string;
+    canary: string;
+    runId?: string;
+    evidence: string;
+}
+export declare function checkCanaries(output: string, scenarios: DatasetScenario[]): CanaryLeak[];
+/**
+ * Behavioral canary: tests the AGENT, not the eval grep.
+ *
+ *   - `forbiddenPattern` PRESENT in output ⇒ AGENT EMITTED BAD CONTENT ⇒ LEAK.
+ *   - `forbiddenPattern` ABSENT from output ⇒ AGENT HELD THE LINE       ⇒ PASS.
+ *
+ * Use when running known-bad-prompt scenarios against the agent under
+ * test and you want to know if the agent misbehaved. The classical
+ * {@link checkCanaries} / {@link import('./canary').runCanaries | runCanaries}
+ * test whether the eval check fires when the bad output is forced
+ * into the eval flow — different question, different answer.
+ *
+ * Pattern resolution order (first match wins):
+ *   1. `scenario.forbiddenPattern` — if it parses as `/body/flags`,
+ *      treated as a regex; otherwise a literal substring.
+ *   2. `scenario.canary` — literal substring fallback so the helper
+ *      works on existing scenario fixtures.
+ *
+ * Returns `null` when nothing forbidden was found OR the scenario
+ * declared no pattern.
+ */
+export declare function checkBehavioralCanary(output: string, scenario: DatasetScenario): CanaryLeak | null;
+/**
+ * Behavioral canary over many (scenario, output) pairs. Sibling to
+ * {@link import('./canary').runCanaries | runCanaries} — same idea
+ * (run-many → report) but the question being answered is "did the
+ * AGENT misbehave?" rather than "did the EVAL grep fire?".
+ *
+ * Returns one `CanaryLeak` per pair where the agent's output
+ * contained its scenario's `forbiddenPattern` (or `canary` fallback).
+ */
+export declare function runBehavioralCanaries(cases: Array<{
+    scenario: DatasetScenario;
+    output: string;
+    runId?: string;
+}>): CanaryLeak[];
+/**
+ * Scan the LLM-output history in a corpus; returns every case where a
+ * canary from a known scenario appeared in agent output. Pass the full
+ * set of scenarios whose canaries you care about (typically the whole
+ * held-out slice).
+ */
+export declare function canaryLeakView(store: TraceStore, scenarios: DatasetScenario[]): Promise<CanaryLeak[]>;
+export declare class HoldoutAuditor {
+    private scenarios;
+    private accessLog;
+    constructor(scenarios: DatasetScenario[]);
+    /** Retrieve a holdout scenario for a declared purpose. Non-'evaluation' throws. */
+    get(scenarioId: string, purpose: 'evaluation' | 'debugging'): DatasetScenario;
+    getAccessLog(): ReadonlyArray<{
+        scenarioId: string;
+        purpose: string;
+        at: number;
+    }>;
+}
+//# sourceMappingURL=contamination-guard.d.ts.map

package/dist/contamination-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contamination-guard.d.ts","sourceRoot":"","sources":["../src/contamination-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAEhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAE/C,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,UAAU,EAAE,CASxF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,eAAe,GACxB,UAAU,GAAG,IAAI,CAUnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,CAAC;IAAE,QAAQ,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAC1E,UAAU,EAAE,CAOd;AA8BD;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,eAAe,EAAE,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAmBvB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,SAAS,CAAiE;gBAEtE,SAAS,EAAE,eAAe,EAAE;IAIxC,mFAAmF;IACnF,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,WAAW,GAAG,eAAe;IAY7E,YAAY,IAAI,aAAa,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CAGnF"}

package/dist/{analyze-runs-DwCEkpO_.d.ts → contract/analyze-runs.d.ts}

@@ -1,8 +1,3 @@
-import { A as AnalystRegistry } from './default-registry-zoGHUQEH.js';
-import { a as DatasetScenario } from './dataset-BbGkaN2I.js';
-import { R as RunRecord } from './run-record-e7vj1uZQ.js';
-import { I as InsightReport } from './insight-report-BBwvOh6x.js';
-
 /**
  * # `analyzeRuns()` — turn a set of agent runs into an actionable decision packet.
  *
@@ -24,8 +19,12 @@ import { I as InsightReport } from './insight-report-BBwvOh6x.js';
  * The `recommendations` array is the human-readable layer; everything
  * else is the evidence backing each recommendation.
  */
-
-interface AnalyzeRunsOptions {
+import type { AnalystRegistry } from '../analyst/registry';
+import type { DatasetScenario } from '../dataset';
+import type { RunRecord } from '../run-record';
+import { type ParetoFigureSpec } from '../summary-report';
+import type { InsightReport } from './insight-report';
+export interface AnalyzeRunsOptions {
     /** The runs to analyze. */
     runs: RunRecord[];
     /** Which split to score against when reading composite from RunOutcome.
@@ -76,6 +75,6 @@ interface AnalyzeRunsOptions {
      *  days", "vs v3.1 release". Surfaces in recommendations + UI. */
     baselineLabel?: string;
 }
-declare function analyzeRuns(opts: AnalyzeRunsOptions): Promise<InsightReport>;
-
-export { type AnalyzeRunsOptions as A, analyzeRuns as a };
+export declare function analyzeRuns(opts: AnalyzeRunsOptions): Promise<InsightReport>;
+export type { ParetoFigureSpec };
+//# sourceMappingURL=analyze-runs.d.ts.map

package/dist/contract/analyze-runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-runs.d.ts","sourceRoot":"","sources":["../../src/contract/analyze-runs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAG1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,mBAAmB,CAAA;AAEtE,OAAO,KAAK,EAGV,aAAa,EASd,MAAM,kBAAkB,CAAA;AAIzB,MAAM,WAAW,kBAAkB;IACjC,2BAA2B;IAC3B,IAAI,EAAE,SAAS,EAAE,CAAA;IACjB;2EACuE;IACvE,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAA;IACrC;;oEAEgE;IAChE,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;iCAC6B;IAC7B,eAAe,CAAC,EAAE,eAAe,EAAE,CAAA;IACnC;uDACmD;IACnD,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB;;mEAE+D;IAC/D,aAAa,CAAC,EAAE;QACd,MAAM,EAAE,MAAM,CAAA;QACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACrC,CAAA;IACD;;uBAEmB;IACnB,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACpE,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;wBAEoB;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;;;;wCAOoC;IACpC,YAAY,CAAC,EAAE,SAAS,EAAE,CAAA;IAC1B;sEACkE;IAClE,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,aAAa,CAAC,CA2FlF;AAu5BD,YAAY,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/contract/define-agent-eval.d.ts

@@ -0,0 +1,52 @@
+import type { RunEvalOptions } from '../campaign/presets/run-eval';
+import type { CampaignResult, DispatchContext, JudgeConfig, MutableSurface, Scenario } from '../campaign/types';
+import type { HostedTenant } from '../hosted/client';
+import { type SelfImproveBudget, type SelfImproveLlm, type SelfImproveOptions, type SelfImproveResult } from './self-improve';
+export type AgentEvalAgent<TScenario extends Scenario, TArtifact> = (surface: MutableSurface, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
+export type DefineAgentEvalOptions<TScenario extends Scenario, TArtifact> = SelfImproveOptions<TScenario, TArtifact>;
+export interface AgentEvalEvaluateOptions<TScenario extends Scenario, TArtifact> extends Omit<RunEvalOptions<TScenario, TArtifact>, 'dispatch' | 'judges' | 'runDir' | 'scenarios'> {
+    /** Scenario set to evaluate. Defaults to the scenarios passed to `defineAgentEval`. */
+    scenarios?: TScenario[];
+    /** Surface to evaluate. Defaults to the baseline surface passed to `defineAgentEval`. */
+    surface?: MutableSurface;
+    /** Agent to evaluate. Defaults to the agent passed to `defineAgentEval`. */
+    agent?: AgentEvalAgent<TScenario, TArtifact>;
+    /** Single judge override. Ignored when `judges` is set. */
+    judge?: JudgeConfig<TArtifact, TScenario>;
+    /** Full judge list override. Defaults to the single judge passed to `defineAgentEval`. */
+    judges?: JudgeConfig<TArtifact, TScenario>[];
+    /** Logical or filesystem run directory. Defaults to an in-memory run. */
+    runDir?: string;
+}
+export type AgentEvalImproveOptions<TScenario extends Scenario, TArtifact> = Omit<Partial<SelfImproveOptions<TScenario, TArtifact>>, 'budget' | 'hostedTenant' | 'llm'> & {
+    budget?: Partial<SelfImproveBudget>;
+    hostedTenant?: Partial<HostedTenant>;
+    llm?: Partial<SelfImproveLlm>;
+};
+export interface DefinedAgentEval<TScenario extends Scenario, TArtifact> {
+    /** The default scenarios used by `evaluate()` and `improve()`. */
+    readonly scenarios: readonly TScenario[];
+    /** The default baseline surface used by `evaluate()` and `improve()`. */
+    readonly baselineSurface: MutableSurface;
+    /**
+     * Run one scored evaluation. Use this for a baseline score or to score one
+     * candidate surface without running an improvement loop.
+     */
+    evaluate(opts?: AgentEvalEvaluateOptions<TScenario, TArtifact>): Promise<CampaignResult<TArtifact, TScenario>>;
+    /**
+     * Run the closed improvement loop. Per-call overrides replace the definition
+     * except for nested config objects (`budget`, `llm`, `hostedTenant`), which
+     * are merged field-by-field so callers can override one knob without
+     * repeating secrets or budget defaults.
+     */
+    improve(opts?: AgentEvalImproveOptions<TScenario, TArtifact>): Promise<SelfImproveResult<TScenario, TArtifact>>;
+}
+/**
+ * Define an agent eval once, then either score a surface with `evaluate()` or
+ * run the closed loop with `improve()`.
+ *
+ * This is a DX wrapper only: it delegates to `runEval()` and `selfImprove()` and
+ * returns their native result shapes.
+ */
+export declare function defineAgentEval<TScenario extends Scenario, TArtifact>(defaults: DefineAgentEvalOptions<TScenario, TArtifact>): DefinedAgentEval<TScenario, TArtifact>;
+//# sourceMappingURL=define-agent-eval.d.ts.map

package/dist/contract/define-agent-eval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-agent-eval.d.ts","sourceRoot":"","sources":["../../src/contract/define-agent-eval.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAGlE,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,WAAW,EACX,cAAc,EACd,QAAQ,EACT,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EAEvB,MAAM,gBAAgB,CAAA;AAEvB,MAAM,MAAM,cAAc,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,IAAI,CAClE,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,SAAS,EACnB,GAAG,EAAE,eAAe,KACjB,OAAO,CAAC,SAAS,CAAC,CAAA;AAEvB,MAAM,MAAM,sBAAsB,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,IAAI,kBAAkB,CAC5F,SAAS,EACT,SAAS,CACV,CAAA;AAED,MAAM,WAAW,wBAAwB,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,CAC7E,SAAQ,IAAI,CACV,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,EACpC,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAC/C;IACD,uFAAuF;IACvF,SAAS,CAAC,EAAE,SAAS,EAAE,CAAA;IACvB,yFAAyF;IACzF,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IAC5C,2DAA2D;IAC3D,KAAK,CAAC,EAAE,WAAW,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IACzC,0FAA0F;IAC1F,MAAM,CAAC,EAAE,WAAW,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAA;IAC5C,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,uBAAuB,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,IAAI,IAAI,CAC/E,OAAO,CAAC,kBAAkB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,EACjD,QAAQ,GAAG,cAAc,GAAG,KAAK,CAClC,GAAG;IACF,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACnC,YAAY,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;IACpC,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;CAC9B,CAAA;AAED,MAAM,WAAW,gBAAgB,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS;IACrE,kEAAkE;IAClE,QAAQ,CAAC,SAAS,EAAE,SAAS,SAAS,EAAE,CAAA;IACxC,yEAAyE;IACzE,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAA;IACxC;;;OAGG;IACH,QAAQ,CACN,IAAI,CAAC,EAAE,wBAAwB,CAAC,SAAS,EAAE,SAAS,CAAC,GACpD,OAAO,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAA;IAChD;;;;;OAKG;IACH,OAAO,CACL,IAAI,CAAC,EAAE,uBAAuB,CAAC,SAAS,EAAE,SAAS,CAAC,GACnD,OAAO,CAAC,iBAAiB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAA;CACpD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,SAAS,QAAQ,EAAE,SAAS,EACnE,QAAQ,EAAE,sBAAsB,CAAC,SAAS,EAAE,SAAS,CAAC,GACrD,gBAAgB,CAAC,SAAS,EAAE,SAAS,CAAC,CAiDxC"}