@tangle-network/agent-eval 0.150.0 → 0.150.2

package/dist/{types-yLK8gXE9.d.ts → types-I5WwVzQ7.d.ts}

@@ -1,4 +1,91 @@
 import { h as RolloutLine } from "./schema-Cef2cFmb.js";
+//#region src/statistics/descriptive.d.ts
+/**
+ * Descriptive statistics: means, bootstrap spread, correlation, and the
+ * weighted judge-dimension composite. Nothing here is a significance test.
+ */
+/** Weighted mean — falls back to uniform weights when omitted */
+declare function weightedMean(scores: {
+  score: number;
+  weight?: number;
+}[]): number;
+/**
+ * Percentile bootstrap confidence interval on the mean of `scores`.
+ *
+ * Descriptive spread. It is not a significance test, and at small n its bounds
+ * are anti-conservative in the same way {@link pairedBootstrap}'s are — see
+ * {@link BOOTSTRAP_GATE_MIN_N}. With no `seed` the resampling is seeded from
+ * the scores themselves, so the interval is reproducible either way.
+ */
+declare function confidenceInterval(scores: number[], confidence?: number, opts?: {
+  seed?: number;
+  resamples?: number;
+}): {
+  mean: number;
+  lower: number;
+  upper: number;
+};
+/** Partial credit: returns 0-1 ratio of current toward target */
+declare function partialCredit(current: number, target: number): number;
+/** Distribution summary of a number series: count, extremes, quantiles, sum. */
+interface SeriesDistribution {
+  readonly n: number;
+  readonly min: number;
+  readonly p50: number;
+  readonly p90: number;
+  readonly max: number;
+  readonly sum: number;
+}
+/**
+ * Fold a number series into its distribution summary. Quantiles use the
+ * nearest-rank definition — the `ceil(q·n)`-th order statistic — so every
+ * reported quantile is a value from the series. Returns `null` for an empty
+ * series: an empty series has no distribution, and a zero-filled summary
+ * would read as a measured all-zero series.
+ */
+declare function summarizeNumberSeries(values: readonly number[]): SeriesDistribution | null;
+/**
+ * Average-rank-with-ties transform (1-indexed). Tied values receive the mean
+ * of the ranks they span, the standard correction for Spearman's ρ.
+ */
+declare function ranks(xs: number[]): number[];
+/**
+ * Pearson product-moment correlation coefficient r ∈ [-1, 1] between two
+ * equal-length series. See the edge-case contract above: NaN for n < 2 or
+ * unequal lengths, 1 when both series are constant, 0 when exactly one is.
+ */
+declare function pearsonR(a: number[], b: number[]): number;
+/**
+ * Spearman's rank correlation ρ — Pearson over the average-rank-with-ties
+ * transform of each series. Same edge-case contract as {@link pearsonR}.
+ */
+declare function spearmanR(a: number[], b: number[]): number;
+interface WeightedCompositeInput {
+  /** Per-dimension scores (typically 0..1). */
+  dims: Record<string, number>;
+  /** Weight per dimension. Every weighted dimension MUST be present in
+   *  `dims` — a weight for an absent dimension is a config error and throws,
+   *  because silently dropping it would renormalise the composite onto a
+   *  different denominator than intended. */
+  weights: Record<string, number>;
+  /** Optional pass threshold; when set, the result reports `pass`. */
+  threshold?: number;
+}
+interface WeightedCompositeResult {
+  composite: number;
+  pass?: boolean;
+}
+/**
+ * Weighted composite over judge dimensions: `Σ(score_d · w_d) / Σ(w_d)` across
+ * the weighted dimensions. The canonical replacement for the per-consumer
+ * hand-rolled composite math (tax/legal/creative/gtm each ship a copy).
+ *
+ * Fail-loud: throws if a weighted dimension is missing from `dims`, if any
+ * weight is negative, or if the weights sum to 0 — none of which can produce
+ * a meaningful composite.
+ */
+declare function weightedComposite(input: WeightedCompositeInput): WeightedCompositeResult;
+//#endregion
 //#region src/supervisor-run/types.d.ts
 /** A metric that could not be computed, with the reason its artifact was missing. */
 interface Unavailable {
@@ -88,6 +175,12 @@ interface SupervisorRunSources {
    * settled `verdict` may be a legacy string or `{ valid, score, ... }`.
    */
   readonly journal: string | null;
+  /**
+   * Source-specific reason `journal` is null. The analyzer uses it verbatim as
+   * the `unavailable` reason on every journal-dependent metric, so a non-loops
+   * layout names its own journal file instead of inheriting the loops paths.
+   */
+  readonly journalMissingReason?: string;
   /** Per-brain-call tap (JSONL): finish_reason, completion tokens, requested max tokens. */
   readonly brainLog: string | null;
   /** Source-specific reason `brainLog` is absent. */
@@ -189,6 +282,15 @@ interface OrchestrationMetrics {
   readonly delegationDepth: Measured<number>;
   readonly timeToFirstSpawnMs: Measured<number>;
   readonly supervisorWallMs: Measured<number>;
+  /**
+   * Which measurement `supervisorWallMs` holds — never a silent substitution.
+   * `stamps`: explicit start and completion stamps. `journal-span`: the start
+   * stamp (or first stamped event) to the last stamped journal event — a
+   * lower bound, derived when the store wrote no completion stamp. `idleMs`,
+   * `idlePct`, and `workerUtilization` cover the same span. Unavailable
+   * exactly when `supervisorWallMs` is, with the same reason.
+   */
+  readonly supervisorWallSource: Measured<'stamps' | 'journal-span'>;
   /** Wall time inside the supervisor run with ZERO live workers. */
   readonly idleMs: Measured<number>;
   readonly idlePct: Measured<number>;
@@ -251,13 +353,33 @@ interface PerWorkerRow {
   /** Numeric verdict score exactly as recorded; null means no score was recorded. */
   readonly score: number | null;
 }
-interface WallDistribution {
-  readonly n: number;
-  readonly min: number;
-  readonly p50: number;
-  readonly p90: number;
-  readonly max: number;
-  readonly sum: number;
+/**
+ * `SeriesDistribution` (from `../statistics`) over per-worker wall
+ * milliseconds. The fold itself is `summarizeNumberSeries`, exported for any
+ * series — fleet wall medians, tokens-per-claim spreads — not only wall.
+ */
+type WallDistribution = SeriesDistribution;
+/** One spend measurement and the number of source records behind it. */
+interface SpendMeasurement {
+  readonly usd: Measured<number>;
+  /** Source records folded into `usd`; 0 when the measurement is unavailable. */
+  readonly records: number;
+}
+/**
+ * The run's total inference spend, measured two ways.
+ *
+ * `closeRecord` is the spend the store recorded as settled when the run
+ * closed (loops `state.json` `result.spentUsd`; Runtime `result.json`
+ * `spentTotal.usd`) — the billing-shaped answer. `journalDerived` is the
+ * spend execution observably consumed (journal `metered` + `settled` rows) —
+ * the execution-accounting answer. Neither is canonical for the other's
+ * question. The two cover different records at different moments, so
+ * divergence between them is itself a signal (a dropped settlement, a
+ * double meter, spend after the close) — read it, never average it away.
+ */
+interface SpendMeasurements {
+  readonly journalDerived: SpendMeasurement;
+  readonly closeRecord: SpendMeasurement;
 }
 interface EconomicsMetrics {
   /** Driver/brain inference — journal `metered` events. */
@@ -272,6 +394,14 @@ interface EconomicsMetrics {
   readonly brainTruncations: Measured<number>;
   /** Worker inference — journal `settled` spend plus the harness session join. */
   readonly workers: RoleSpend;
+  /** Both total-spend measurements, each with its own record count. */
+  readonly spend: SpendMeasurements;
+  /**
+   * One collapsed number kept for existing consumers: the close record when
+   * the store wrote one, else the journal-derived sum. `totalUsdSource` names
+   * the pick. Prefer `spend` — the collapse hides which accounting question
+   * the number answers.
+   */
   readonly totalUsd: Measured<number>;
   /**
    * Where `totalUsd` came from. CLI-backend workers never price their own inference into
@@ -343,7 +473,27 @@ interface SupervisorRunRollup {
   readonly idlePctMean: Measured<number>;
   readonly workersSpawnedTotal: Measured<number>;
   readonly acceptedTotal: Measured<number>;
+  /**
+   * Sum of the per-run collapsed `totalUsd`. Prefer `spendUsd`: this total
+   * mixes close-record and journal-derived cells without saying which.
+   */
   readonly usdTotal: Measured<number>;
+  /**
+   * Fleet spend measured two ways. `runs` is each measurement's own
+   * denominator — the cells where that measurement was available. The two
+   * sums cover different run sets, so comparing the values without their
+   * denominators manufactures a phantom divergence.
+   */
+  readonly spendUsd: {
+    readonly journalDerived: {
+      readonly value: Measured<number>;
+      readonly runs: number;
+    };
+    readonly closeRecord: {
+      readonly value: Measured<number>;
+      readonly runs: number;
+    };
+  };
   readonly resolvedCount: Measured<number>;
   readonly perCell: readonly RollupCellRow[];
 }
@@ -368,5 +518,5 @@ interface SupervisorRunTreeGap {
   readonly count?: number;
 }
 //#endregion
-export { Unavailable as C, showMeasured as D, isUnavailable as E, unavailable as O, SupervisorRunTreeGapCode as S, WorkerLogSource as T, SupervisorRunReport as _, OrchestrationMetrics as a, SupervisorRunTree as b, PerWorkerRow as c, SUPERVISOR_RUN_ROLLUP_SCHEMA as d, SUPERVISOR_RUN_SCHEMA as f, SupervisorRunReader as g, SupervisorRunNodeRole as h, NO_SOURCE_LIMITS as i, RoleSpend as l, SteerBreakdown as m, EconomicsMetrics as n, OutcomeMetrics as o, SourceLimits as p, Measured as r, PatchStats as s, DecisionMetrics as t, RollupCellRow as u, SupervisorRunRollup as v, WallDistribution as w, SupervisorRunTreeGap as x, SupervisorRunSources as y };
-//# sourceMappingURL=types-yLK8gXE9.d.ts.map
+export { unavailable as A, weightedComposite as B, SupervisorRunTreeGap as C, WorkerLogSource as D, WallDistribution as E, partialCredit as F, pearsonR as I, ranks as L, WeightedCompositeInput as M, WeightedCompositeResult as N, isUnavailable as O, confidenceInterval as P, spearmanR as R, SupervisorRunTree as S, Unavailable as T, weightedMean as V, SupervisorRunNodeRole as _, OrchestrationMetrics as a, SupervisorRunRollup as b, PerWorkerRow as c, SUPERVISOR_RUN_ROLLUP_SCHEMA as d, SUPERVISOR_RUN_SCHEMA as f, SteerBreakdown as g, SpendMeasurements as h, NO_SOURCE_LIMITS as i, SeriesDistribution as j, showMeasured as k, RoleSpend as l, SpendMeasurement as m, EconomicsMetrics as n, OutcomeMetrics as o, SourceLimits as p, Measured as r, PatchStats as s, DecisionMetrics as t, RollupCellRow as u, SupervisorRunReader as v, SupervisorRunTreeGapCode as w, SupervisorRunSources as x, SupervisorRunReport as y, summarizeNumberSeries as z };
+//# sourceMappingURL=types-I5WwVzQ7.d.ts.map

package/dist/types-I5WwVzQ7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-I5WwVzQ7.d.ts","names":[],"sources":["../src/statistics/descriptive.ts","../src/supervisor-run/types.ts"],"mappings":"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"}

package/dist/{types-COAJy8Ku.d.ts → types-jUBXJ7Iz.d.ts}

@@ -289,7 +289,7 @@ declare function assertCrossFamilyServed(pairs: ReadonlyArray<{
 //#endregion
 //#region src/llm-client.d.ts
 interface LlmMessage {
-  role: 'system' | 'user' | 'assistant';
+  role: 'system' | 'user' | 'assistant' | 'tool';
   /**
    * Either a plain text content string OR a multimodal content array
    * (text + image_url parts) for vision-capable models.
@@ -304,8 +304,35 @@ interface LlmMessage {
       detail?: 'auto' | 'low' | 'high';
     };
   }>;
+  /** Tool invocations made by an `assistant` message earlier in the turn. */
+  toolCalls?: LlmToolCall[];
+  /** The invocation a `tool` message answers. Required when role is `tool`. */
+  toolCallId?: string;
 }
 type LlmThinkingMode = 'enabled' | 'disabled';
+/** Canonical function-tool definition offered to the model. */
+interface LlmToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+  };
+}
+/** Canonical tool-choice policy; meaningful only when `tools` is present. */
+type LlmToolChoice = 'auto' | 'none' | 'required' | {
+  type: 'function';
+  function: {
+    name: string;
+  };
+};
+/** One tool invocation on a response or an assistant history message. */
+interface LlmToolCall {
+  id: string;
+  name: string;
+  /** JSON-encoded arguments, exactly as the provider produced them. */
+  argumentsJson: string;
+}
 interface LlmCallRequest {
   model: string;
   messages: LlmMessage[];
@@ -316,6 +343,10 @@ interface LlmCallRequest {
     name: string;
     schema: Record<string, unknown>;
   };
+  /** Function tools offered to the model for this call. */
+  tools?: LlmToolDefinition[];
+  /** Tool-choice policy for `tools`. */
+  toolChoice?: LlmToolChoice;
   temperature?: number;
   maxTokens?: number;
   /** OpenAI-compatible reasoning mode. Omitted when the provider default should apply. */
@@ -327,7 +358,7 @@ interface LlmCallRequest {
  * Returns undefined when output or multimodal input is not bounded, causing a
  * capped CostLedger to reject the call before execution. Pass
  * `customTokenPricing` when package pricing does not cover the model or endpoint. */
-declare function maximumChargeForLlmRequest(request: Pick<LlmCallRequest, 'model' | 'messages' | 'jsonSchema' | 'maxTokens' | 'thinking'>, options?: LlmClientOptions): MaximumCharge | undefined;
+declare function maximumChargeForLlmRequest(request: Pick<LlmCallRequest, 'model' | 'messages' | 'jsonSchema' | 'tools' | 'toolChoice' | 'maxTokens' | 'thinking'>, options?: LlmClientOptions): MaximumCharge | undefined;
 interface LlmUsage {
   promptTokens: number;
   completionTokens: number;
@@ -342,6 +373,8 @@ interface LlmUsage {
 interface LlmCallResult {
   /** The text content of the first choice. Empty string if none. */
   content: string;
+  /** Tool invocations from the first choice, when the model called tools. */
+  toolCalls?: LlmToolCall[];
   usage: LlmUsage;
   /**
    * Cost in USD. Uses the provider's reported cost when present, otherwise
@@ -848,4 +881,4 @@ interface CheckResult {
 }
 //#endregion
 export { assertServedModels as $, LlmClientOptions as A, isTransientLlmError as B, SandboxSdkTransportOpts as C, LlmCallRequest as D, LlmCallMetadata as E, assertLlmRoute as F, AssertServedModelOptions as G, probeLlm as H, callLlm as I, ServedModelCheck as J, ModelSubstitutionError as K, callLlmJson as L, LlmResponseError as M, LlmRouteRequirements as N, LlmCallResult as O, LlmUsage as P, assertServedModel as Q, costReceiptFromLlm as R, RouterTransportOpts as S, LlmCallError as T, stripFencedJson as U, maximumChargeForLlmRequest as V, AssertCrossFamilyServedOptions as W, ServedModelVerdict as X, ServedModelPolicy as Y, assertCrossFamilyServed as Z, CliBridgeTransportOpts as _, defaultProviderRedactor as _t, JudgeInput as a, assertCrossFamily as at, DirectProviderTransportOpts as b, PersonaConfig as c, FileSystemRawProviderSinkOptions as ct, Scenario as d, NoopRawProviderSink as dt, checkServedModel as et, ChatCallOpts as f, ProviderRedactor as ft, ChatTransport as g, RawProviderSinkFilter as gt, ChatResponse as h, RawProviderSink as ht, JudgeFn as i, JudgeFamily as it, LlmMessage as j, LlmClient as k, ProductClientConfig as l, InMemoryRawProviderSink as lt, ChatRequest as m, RawProviderEvent as mt, CompletionCriterion as n, AssertCrossFamilyOptions as nt, JudgeRubric as o, judgeFamily as ot, ChatClient as p, RawProviderDirection as pt, ServedCrossFamilyError as q, DriverState as r, CrossFamilyError as rt, JudgeScore as s, FileSystemRawProviderSink as st, CheckResult as t, servedModelAcceptable as tt, RouteMap as u, InMemoryRawProviderSinkOptions as ut, CreateChatClientOpts as v, providerFromBaseUrl as vt, createChatClient as w, MockTransportOpts as x, CustomTransportOpts as y, costReceiptFromLlmError as z };
-//# sourceMappingURL=types-COAJy8Ku.d.ts.map
+//# sourceMappingURL=types-jUBXJ7Iz.d.ts.map

package/dist/types-jUBXJ7Iz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-jUBXJ7Iz.d.ts","names":[],"sources":["../src/trace/raw-provider-sink.ts","../src/judge-families.ts","../src/integrity/served-model.ts","../src/llm-client.ts","../src/analyst/chat-client.ts","../src/types.ts"],"mappings":"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"}

package/dist/wire/index.d.ts

@@ -1,7 +1,7 @@
 import { c as CostLedgerHandle } from "../cost-ledger-DbQdN3nO.js";
-import { A as LlmClientOptions, N as LlmRouteRequirements } from "../types-COAJy8Ku.js";
+import { A as LlmClientOptions, N as LlmRouteRequirements } from "../types-jUBXJ7Iz.js";
 import { s as TraceStore } from "../store-CT9YIIve.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-Cc9M2tNF.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-DpTTjo0q.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";

package/dist/wire/index.js

@@ -1,2 +1,2 @@
-import { A as TraceEventSchema, C as HealthResponseSchema, D as RubricDimensionSchema, E as ListRubricsResponseSchema, F as hashRubric, M as TracesIngestResponseSchema, N as VersionResponseSchema, O as RubricInfoSchema, P as WIRE_VERSION, S as FeedbackTrajectorySchema, T as JudgeResultSchema, _ as ErrorResponseSchema, a as runRpcBatch, b as FeedbackIngestResponseSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as listBuiltinRubrics, h as getBuiltinRubric, i as dispatchRpc, j as TracesIngestRequestSchema, k as RubricSchema, l as handleFeedbackIngest, m as BUILTIN_RUBRICS, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FailureModeSchema, w as JudgeRequestSchema, x as FeedbackLabelSchema, y as FeedbackAttemptSchema } from "../server-DNiUVirV.js";
+import { A as TraceEventSchema, C as HealthResponseSchema, D as RubricDimensionSchema, E as ListRubricsResponseSchema, F as hashRubric, M as TracesIngestResponseSchema, N as VersionResponseSchema, O as RubricInfoSchema, P as WIRE_VERSION, S as FeedbackTrajectorySchema, T as JudgeResultSchema, _ as ErrorResponseSchema, a as runRpcBatch, b as FeedbackIngestResponseSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as listBuiltinRubrics, h as getBuiltinRubric, i as dispatchRpc, j as TracesIngestRequestSchema, k as RubricSchema, l as handleFeedbackIngest, m as BUILTIN_RUBRICS, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FailureModeSchema, w as JudgeRequestSchema, x as FeedbackLabelSchema, y as FeedbackAttemptSchema } from "../server-dIWwF3j_.js";
 export { BUILTIN_RUBRICS, ErrorResponseSchema, FailureModeSchema, FeedbackAttemptSchema, FeedbackIngestResponseSchema, FeedbackLabelSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RubricDimensionSchema, RubricInfoSchema, RubricSchema, TraceEventSchema, TracesIngestRequestSchema, TracesIngestResponseSchema, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };

package/docs/adapters-observability.md

@@ -41,26 +41,13 @@ it*. Unified at the trace level, you see both as one timeline per cell.
 - Compose: register TraceAI's instrumentations on the global tracer
   provider, then either point both at your OTLP collector or at
   TraceAI's hosted backend if you want their UI.
-- **A bridge exists in source but is not published:** `createOtelBridge`
-  (`src/adapters/otel.ts`) converts finished OTel spans (`ReadableSpan`
-  shape) and forwards them into the hosted-tier ingest, lifting
-  `tangle.runId` / `tangle.scenarioId` / `tangle.cellId` /
-  `tangle.generation` to first-class wire fields so the dashboard pivots
-  correctly. As of 0.140.x there is no `./adapters/otel` entry in
-  `package.json` `exports`, so it is not importable from the published
-  package — the snippet below documents the design; it will throw
-  `ERR_PACKAGE_PATH_NOT_EXPORTED` against `@tangle-network/agent-eval`
-  installed from npm.
-  ```ts
-  // (not currently published — see status note above)
-  import { createHostedClient } from '@tangle-network/agent-eval/hosted'
-  import { createOtelBridge } from '@tangle-network/agent-eval/adapters/otel'
-
-  const client = createHostedClient({ endpoint, apiKey, tenantId })
-  const bridge = createOtelBridge({ client, defaultRunId: substrateRunId })
-  processor.onEnd = (span) => { void bridge.ingest([span]) }
-  // ...or call `bridge.ingest(batch)` from a SpanProcessor.onShutdown.
-  ```
+- **No OTel-span-to-hosted-ingest bridge ships.** To land finished OTel
+  spans in the hosted tier, write your own mapping from the span shape to
+  `TraceEvent` rows and post them through `createHostedClient` from
+  `@tangle-network/agent-eval/hosted` or the `/v1/traces/ingest` wire
+  route ([wire-protocol.md](./wire-protocol.md#tracesingest-batch-ingest-production-trace-events)).
+  For run records that already exist, `fromOtelSpans` from `/contract`
+  converts collector output into `RunRecord[]` for `analyzeRuns()`.
 
 ### Langfuse SDK
 
@@ -131,9 +118,8 @@ OTel-protocol composition:
 1. **Cost-aware judging.** Your observability tool's auto-instrumented
    spans carry token counts + cost. A custom `JudgeConfig` can read
    them via the OTel context and refuse to score artifacts that
-   exceeded a per-call budget. Easy to write yourself; we'll ship a
-   reference helper (`costAwareJudgeFromOtel`) when a partner pulls on
-   this.
+   exceeded a per-call budget. Easy to write yourself; no reference
+   helper ships today.
 2. **Tool-aware judging.** Your instrumentation captures the tool-call
    sequence (`langchain.tool.invoked`, `openai.function.called`, etc.).
    A judge that scores "did the agent use the right tool" reads those

package/docs/campaign-proposers.md

@@ -332,16 +332,28 @@ The credential stays inside the owner closure; the proxy still enforces every bu
 ### Metered agent CLI engines
 
 The `autoresearch` and `meta_harness` engines drive a `claude` CLI subprocess.
+They ship only in the tested official source revision, not in the published `gepa` package (see [Install Official GEPA](#install-official-gepa)).
 Set `optimizer.anthropicEndpoint: true` to admit them in proxied mode.
+This path is measured live: a real `claude` CLI session completes with every tool call translated and every call metered.
 The loopback proxy then also serves `POST /v1/messages` (Anthropic Messages API) and the bridge child receives `ANTHROPIC_BASE_URL`, an ephemeral `ANTHROPIC_AUTH_TOKEN`, and `ANTHROPIC_MODEL` in its environment.
 Every CLI call becomes one canonical execution-owner call with the same reservation, receipt, and budget pipeline as reflection traffic; the run fails if the receipt count differs from the admitted call count.
 Each agent engine run must set `engineConfig.model` to `optimizer.model`, because the engines pass `--model` and that flag beats the injected environment.
-The endpoint translates text conversations only; it refuses tool use, thinking, images, `top_p`, `top_k`, and `stop_sequences` with a loud Anthropic error envelope.
+The endpoint translates text and tool-use conversations.
+Anthropic `tools`, `tool_choice`, `tool_use`, and `tool_result` map onto the canonical execution-owner contract, and a tool-calling response is synthesized back as the Anthropic stream shape the CLI expects.
+System text translates from both slots the CLI uses: the top-level `system` field and system-role turns injected inside `messages`.
+Claude-specific control fields (`thinking`, `context_management`, `output_config`) carry no token-billing semantics on the owner wire; the shim strips them and records the names in the ledger tag `strippedFields`.
+It still refuses images, server tools, `top_p`, `top_k`, and `stop_sequences` with a loud Anthropic error envelope.
 A budget refusal surfaces to the CLI as HTTP 402, which the CLI treats as terminal instead of retrying.
 Agent sessions are chatty: size `budget.maxRequests` for tens of calls per engine run.
 Without the flag, agent engines stay rejected in proxied mode.
 
-Other official engines can still receive their own settings:
+**The `-inf` trap.**
+GEPA scores an agent-engine candidate as one aggregate evaluation over the whole train set.
+That one registering evaluation costs `trainSet.length` callback evaluations against `maxEvaluations`.
+When `maxEvaluations` is below the train-set size, the callback rejects mid-aggregate and GEPA records the candidate score as `-inf`.
+Set `maxEvaluations` to at least the train-set size for every registering evaluation you expect.
+
+Without `optimizer`, an engine runs unproxied and can receive its own settings:
 
 ```ts
 recipe: {
@@ -357,7 +369,7 @@ recipe: {
 }
 ```
 
-Their external model spend remains incomplete unless that engine reports it.
+Its external model spend remains incomplete unless that engine reports it.
 Supply provider API keys only through `runner.env`.
 An exported shell variable never reaches the bridge child.
 The spawn builds the child environment from a fixed allowlist of benign variables (PATH, HOME, locale, `PYTHONPATH`) plus `runner.env`, so the parent environment is stripped by construction.
@@ -387,6 +399,9 @@ The table names the failure so you can set the knob before the run dies mid-spen
 | `reflection_lm_kwargs.num_retries` | litellm default (3) | Each failed reflection request retries 3 times inside litellm, so the proxy meters 4 request attempts per logical call and `budget.maxRequests` exhausts 4x early. Set `num_retries: 0`; the proxy already accounts each attempt. | `recipe.run.engineConfig.reflection.reflection_lm_kwargs` |
 | `reflection_lm_kwargs.max_tokens` | `budget.maxOutputTokensPerRequest` | Every reflection request ships the full budget cap as `max_tokens`. A provider family with a lower completion cap rejects every call. A reasoning model also needs headroom for hidden reasoning tokens. Set a value at or below the smallest family cap; it must not exceed `budget.maxOutputTokensPerRequest`. | `recipe.run.engineConfig.reflection.reflection_lm_kwargs` |
 | `maxProposerCostUsd` | unset | Without it, one engine stage can spend up to `optimizer.budget.maxCostUsd` or the campaign `costCeiling` before any limit fires. Supply it only when the execution owner can enforce billed USD. | `recipe.run.maxProposerCostUsd` |
+| `maxEvaluations` (agent engines) | required, no default | An agent engine registers one aggregate evaluation that costs the full train set of callback evaluations. A value below the train-set size rejects mid-aggregate and GEPA records the candidate as `-inf`. | `recipe.run.maxEvaluations` |
+| `budget.maxRequests` (agent engines) | required, no default | An agent CLI session makes tens of calls per engine run. A text-campaign-sized limit exhausts mid-run, and the CLI sees a terminal 402. | `optimizer.budget.maxRequests` |
+| `expectUsage` | `'assert'` | A deterministic evaluator that makes no LLM calls records zero usage, so `'assert'` fails the run as a stub. Set `'off'` only for an evaluator with no paid calls. | `selfImprove({ expectUsage })` |
 
 ## Install Official SkillOpt
 

package/docs/concepts.md

@@ -275,10 +275,9 @@ That drop is the signal.
 
 Every reported interval is a bootstrap 95 % interval: the statistic is recomputed on many resamples of the data, and the middle 95 % of those values is the interval.
 
-Three bias probes cover three separate failure modes.
-`positionalBias` finds a judge that scores by position.
-`verbosityBias` finds one that scores by length.
-`selfPreference` finds one that prefers output from its own model family.
+`verbosityBias` is the one exported bias probe: it finds a judge that rewards length regardless of quality.
+The `JudgeInsight` report shape also carries optional `positionalBias` and `selfPreference` fields for caller-computed probes.
+No built-in computes those two fields.
 
 ## Trace Model
 

package/docs/wire-protocol.md

@@ -100,7 +100,7 @@ GET /v1/version
 ```json
 {
   "package": "@tangle-network/agent-eval",
-  "version": "0.140.1",
+  "version": "0.150.1",
   "wireVersion": "1.0.0",
   "apiSurface": ["judge", "listRubrics", "version", "feedback.ingest", "traces.ingest"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.150.0",
+  "version": "0.150.2",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {