@tangle-network/agent-eval 0.180.0 → 0.181.0

package/CHANGELOG.md

@@ -4,6 +4,66 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
+## Unreleased
+
+## [0.181.0] — 2026-09-14
+
+### Changed
+
+- README and example guides include verified execution commands, public imports, and explicit limits on fixture results and release evidence.
+  The existing-agent quickstart is offline; its guide shows how to meter paid calls with the maintained transport and receipt helpers.
+- The single-optimizer example accepts the same worker `PRICE_*` settings as the method-comparison example.
+  Both use one parser to validate endpoint rates before execution.
+- **Breaking:** Root `Scenario`, `JudgeScore`, and `GateDecision` now match `/contract`.
+  Product workflows use `ProductScenario`, `DimensionJudgeScore`, and `HeldOutGateDecision`.
+- **Breaking:** Current canonical envelopes and algorithm identifiers are required for seals, attestations, and profile identities.
+  Retired digest readers and canonical-JSON waiver paths are removed.
+  Historical evidence retains its original identity.
+- **Breaking:** Cluster interval registrations bind their measured `value` field.
+  Row execution evidence supplies rows; it cannot select another metric under the same seal.
+- **Breaking:** Power calculations and power-floor gates require `minimumEffect` and assess adequacy at that effect.
+- **Breaking:** Predictive validity requires a declared outcome direction and uses descriptive `aligned`, `inverse`, and `weak` associations.
+  Research proposals retain hypotheses instead of invented expected gains.
+- **Breaking:** Adaptation comparisons require matched identified scenario cohorts and report paired uncertainty and inconclusive results.
+  Contamination diagnostics use `alpha`; heuristic per-item `qValue` values are removed.
+- Method comparisons expose unit-level scores, raw paired-cell counts, and the deciding statistical evidence.
+  `favored: null` replaces the ambiguous `tie` sentinel for inconclusive comparisons.
+  Continuous mean decisions cannot use a small-sample sign test as evidence about the mean.
+  Binary and explicit median decisions retain their appropriate confidence-dependent observation requirements.
+
+### Added
+
+- Optional top-level `claim` metadata declares populations and independent source units without consuming reusable regression evidence.
+  New-unit claims keep source families together across automatic partitions.
+  Self-improvement retains the selected candidate when release evidence is negative or inconclusive.
+- Optional `finalEvidence` reserves fresh final units before search and records exposure before final measurement.
+  The shared journal detects conflicting use, concurrent ownership, corrupted history, and deleted trusted heads.
+- `/meta-eval` exports evaluator admission from actual controls, simultaneous error bounds, and explicit unknown and excluded evidence.
+  Existing position and self-preference audits are public alongside calibration and verbosity diagnostics.
+- `calibrationFromPairs()` accepts direct measured rows without requiring trace and outcome stores.
+- Pareto objectives and paired promotion accept `binaryScale` for declared binary outcomes, including zero-only error observations.
+  Default Pareto regression tolerances use the declared scale.
+- The [evaluation-integrity guide](docs/evaluation-integrity.md) explains methodology and limits.
+  Its offline example composes public imports and exports actual fixture results.
+
+### Fixed
+
+- Failure-cluster shares count all affected failed runs independently of the five displayed examples.
+  Multiple findings in the same cluster count once per run.
+- Outcome queries select the latest finite requested metric instead of an unrelated latest observation.
+  Outcome-store corruption and unavailable evidence remain visible failures.
+- Calibration preserves clipped observations, measures constant predictors, and honors the requested bin count.
+- Registered-unit gates pair complete cells before aggregation; repetitions and source variants cannot multiply independent evidence.
+  Cell reduction preserves identical judge scores exactly, including decimal binary scales.
+- Opened experiments and outcome research retain validated snapshots instead of mutable caller-owned rules.
+- Comparisons capture judge configuration and callbacks before asynchronous work.
+  Replacing a caller's judge between arms cannot create artificial lift under the original evaluator identity.
+- Pareto promotion applies regression floors to the deciding confidence interval.
+  Tied binary outcomes cannot bypass a safety floor through a zero-width diagnostic bootstrap.
+  Gate explanations describe failed floors without treating uncertainty as an observed regression.
+  Zero-width or non-finite deciding intervals now produce an `indeterminate` axis and `not_evaluated` check.
+  They require more evidence before promotion, including undeclared all-zero outcomes and constant continuous differences.
+
 ## [0.180.0] — 2026-09-09
 
 - Preserve named-resource receipts in supervisor-run facts, JSON reports, and comparison cells.

package/README.md

@@ -1,29 +1,28 @@
 # `@tangle-network/agent-eval`
 
-Measure agent behavior, compare changes on the same cases, and improve prompts or skills without showing the final test cases to the optimizer.
+Run agent evaluations, compare changes on the same cases, and decide whether a candidate has enough evidence to release.
 
 [![npm](https://img.shields.io/npm/v/@tangle-network/agent-eval.svg)](https://www.npmjs.com/package/@tangle-network/agent-eval)
 [![pypi](https://img.shields.io/pypi/v/agent-eval-rpc.svg)](https://pypi.org/project/agent-eval-rpc/)
 [![tests](https://github.com/tangle-network/agent-eval/actions/workflows/ci.yml/badge.svg)](https://github.com/tangle-network/agent-eval/actions/workflows/ci.yml)
 [![license: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE)
 
-The evaluation path runs in your TypeScript process.
-Model calls happen only through the clients and agents you configure.
-
-New to the package? Read [concepts](./docs/concepts.md) first — it takes five minutes and defines every word used here.
-
-Looking for a measured result (a lift, a null, a parity verdict)? The canonical registry is [`evidence/`](./evidence/README.md) — machine-readable records, a generated index, and a freshness gate.
+Eval runs in your TypeScript process.
+You supply agent execution, judges, and model transports.
+It records outputs, failures, costs, and evidence for each comparison.
 
 ## Install
 
+Use Node.js 20.19 or newer.
+
 ```sh
 pnpm add @tangle-network/agent-eval
 ```
 
 ## Quickstart
 
-This example is offline and complete.
-Copy it, run it, then replace the agent and the judge with your product code.
+This complete example runs offline.
+Save it as `eval.mts`.
 
 ```ts
 import { defineAgentEval } from '@tangle-network/agent-eval/contract'
@@ -53,186 +52,147 @@ const evalKit = defineAgentEval<SupportCase, string>({
   expectUsage: 'off',
 })
 
-console.log((await evalKit.evaluate()).aggregates.byJudge)
-console.log(
-  (await evalKit.evaluate({ surface: 'Answer politely and cite the ticket id.' })).aggregates
-    .byJudge,
-)
-```
-
-Each call runs every case, records what the agent produced, applies the same judge, and returns score distributions.
+const baseline = await evalKit.evaluate()
+const candidate = await evalKit.evaluate({
+  surface: 'Answer politely and cite the ticket id.',
+})
 
-Three words carry this example.
-A **case** is one task the agent must do.
-A **surface** is the value being changed: a prompt, a skill, or a serialized configuration.
-A **judge** is a function that scores one produced result.
+console.log('baseline:', baseline.aggregates.byJudge['ticket-id']?.mean)
+console.log('candidate:', candidate.aggregates.byJudge['ticket-id']?.mean)
+```
 
-`expectUsage: 'off'` is set because this agent makes no paid calls.
-The default, `'assert'`, fails a run whose cells report no cost receipt.
-Keep the default whenever real model calls happen.
+Run it with a TypeScript runner:
 
-Runnable copy: [`examples/evaluate-a-change`](./examples/evaluate-a-change/).
+```sh
+pnpm add --save-dev tsx
+pnpm exec tsx eval.mts
+```
 
-## Auditable optimization history
+```text
+baseline: 0
+candidate: 1
+```
 
-Optimization methods may return a bounded `SearchHistoryReceipt` over Eval's canonical hash-chained `SearchLedger`. Existing callers keep working and see missing-history coverage. Autonomous and publication-grade runs set `searchHistoryPolicy: 'require-complete'` to refuse an incomplete planned denominator before the untouched final cases are opened.
+The baseline scores `0`; the candidate scores `1` on all three cases.
+These scores describe the three examples.
+They do not establish a release decision or performance on new tasks.
 
-The receipt is a small proof envelope, not another event log. Exact candidates, attempts, failures, decisions, and missing ids remain in the ledger. See [complete optimization search history](./docs/search-history-receipts.md).
+A **case** is one task.
+A **surface** is the prompt, skill, or configuration being changed.
+A **judge** scores the agent's result.
 
-## Which Front Door
+`expectUsage: 'off'` applies because this example makes no paid calls.
+Set `expectUsage: 'assert'` for paid agents so missing dispatch receipts become execution failures.
+The [runnable example](./examples/evaluate-a-change/) uses the same evaluation.
+The [existing-agent example](./examples/foreign-agent-quickstart/) shows how to connect your agent and record model usage.
 
-Every row is a function you call. Each links to a runnable example.
+## Choose a workflow
 
-| When to call it | What you give it | What you get back |
+| Intent | Start with | Result |
 |---|---|---|
-| [`defineAgentEval()`](./examples/evaluate-a-change/) — you changed a surface and must know whether it helped | cases, an agent, a judge, a starting surface | `evaluate()` for scores, `improve()` for a search plus a release decision |
-| [`selfImprove()`](./examples/selfimprove-quickstart/) — you want candidate generation, scoring, and a release decision in one call | cases, an agent, a judge, a starting surface | a report, a winner surface, and a `gateDecision` |
-| [`analyzeRuns()`](./examples/analyze-existing-runs/) — the runs already happened and no agent needs to run again | `RunRecord[]` | an `InsightReport`: distributions, paired lift, judge agreement, cost, failure clusters |
-| `fromFeedbackTable()` ([example](./examples/customer-feedback-loop/)) / `fromOtelSpans()` ([example](./examples/customer-otel-traces/)) — your data is in a table or an OTel collector, not in `RunRecord` shape | source rows or spans | `RunRecord[]` ready for `analyzeRuns()` |
-| [`planCampaignRun()` / `runCampaign()`](./examples/plan-before-you-spend/) — you need direct control of the case grid, or you must see it before paying for it | cases, a dispatch function, judges, a run directory | a per-cell schedule, then a campaign result with cached cells |
-| [`loadEvalFixtureScenarios()`](./examples/eval-fixtures-quickstart/) — agents should add cases as folders on disk | `evals/<name>/PROMPT.md` plus checks | `Scenario[]` for `runCampaign()` |
-| [`compareOptimizationMethods()`](./examples/compare-optimization-methods/) — two search methods must be compared at equal budget | methods, a starting surface, train, selection, and final cases | per-method final lift, intervals, pairwise contrasts, and cost |
-| [`gepaOptimizationMethod()` / `skillOptOptimizationMethod()`](./examples/compare-optimization-methods/) — official GEPA or Microsoft SkillOpt should own the search | an objective, a recipe or trainer, an optimizer budget | an optimization method for the comparison above |
-| [`externalTextOptimizationMethod()`](./examples/adapt-a-text-optimizer/) — another package owns text search and you keep the scoring | the package identity, limits, and a `run` callback | the same, with the final cases never exposed |
-| [`SurfaceProposer`](./examples/selfimprove-quickstart/) — candidate generation belongs to your product | a `propose()` function | candidates the campaign executes, scores, and gates |
-| [`runProfileMatrix()`](./examples/profile-matrix/) — the same cases must run across models or profiles | axes of models and profiles, cases | one row per cell, with an explicit `unknown` model rather than an invented one |
-| [`ExperimentTracker`](./examples/experiment-evidence/) — a candidate must beat its parent across N repetitions | reps with scores, run ids, and evidence references | a KEEP / ITERATE / NOISE / REGRESSION verdict with git provenance |
-| [`sealExperiment()` / `openSealedExperiment()`](./examples/sealed-experiment/) — the result must convince someone who does not trust you | arms, an admission funnel, an estimand, an interval, a decision table | a hashed rule tree, and executors that can run no other rule |
-| [`runEquivalenceCheck()` / `VERIFICATION_STRATEGIES`](./examples/verify-without-an-answer-key/) — the work has no held-out test suite | a claim, two blind arms, an injected checker | a certification that names who vouched and how it can fail |
-| [`AnalystRegistry.runExact()`](./examples/custom-trace-analyst/) — a batch of runs failed and you need cited findings | recorded evidence, a declared analyst list | findings with evidence references, an execution plan, and a receipt |
-| [`analyzeTraces()`](./docs/trace-analysis.md#answer-one-question) — you have one question about a recorded run ("what first caused this failure?") | stored traces, the question, a DSPy RLM engine with a cost cap | an answer, findings with evidence references, and the investigation trajectory |
-| [`runAnalystBenchmark()`](./docs/trace-analysis.md) — an analyst's accuracy must be measured, not assumed | labeled issues and exact span locations | scored findings, trace reads, model calls, tokens, cost, and runtime |
-| [`deltaRepair()`](./docs/trace-repair-grader.md) — a finding must be graded by executing the repair it proposes | a trajectory, an analyst finding, a sandbox | the repair's measured effect against a no-fix control |
-| [`replayVerify()`](./docs/trajectory-replay.md) — you must know whether a recorded failure still reproduces | a recorded shell trajectory and its pinned image | a re-execution verdict and the divergences found |
-| [`analyzeSupervisorRun()`](./docs/adapters-observability.md) — a recursive or supervised run directory must be read | a run directory | counts that stay missing when a measurement is missing, never zero |
-| [`plantByPerturbation()` / `seedPlants()` / `catchRate()`](./docs/plants.md) — you must know whether the grader catches a wrong answer, not only how the work scored | a grading set, and claims the grader verified | items authored wrong by one value, a sealed manifest, then a catch rate that refuses rather than guessing |
-| [`buildRlDataset()`](./examples/publish-rl-dataset/) — scored runs should become training data | run records and preferences | reward, preference, and supervised rows |
-
-## Configure Model Calls
-
-Benchmarks, user drivers, executors, built-in judges, completion checkers, and judge adapters all take the same `ChatClient`.
-You own model execution, and Agent Eval never goes looking for a credential: it reads no environment variable to find one, and every transport is bound at the call site.
-
-Bind a transport one of two ways. Pass a `chat` function you wrote:
+| Score one change | [`defineAgentEval()`](./examples/evaluate-a-change/) from `/contract` | Cell results, failures, score distributions, and measured cost. |
+| Search for a better surface | [`selfImprove()`](./examples/selfimprove-quickstart/) from `/contract` | A selected surface, final comparison, and `gateDecision`. |
+| Compare search methods | [`compareOptimizationMethods()`](./examples/compare-optimization-methods/) from `/campaign` | Paired final comparisons, uncertainty, coverage, and costs under declared budgets. |
+| Register evidence and decision rules | [`defineEvaluationClaim()` and `sealExperiment()`](./docs/evaluation-integrity.md) from `/experiment` | A declared population, independent unit, optional practical effect, and sealed rules. |
+| Check the evaluator | [`auditEvaluator()`](./docs/evaluation-integrity.md) and [calibration tools](./docs/outcome-validity.md) from `/meta-eval` | Error rates, admission evidence, bias diagnostics, and outcome associations. |
+| Analyze completed work | [`analyzeRuns()`](./examples/analyze-existing-runs/) from `/contract`; [trace analysts](./docs/trace-analysis.md) from `/analyst` | Comparisons and findings with links to recorded evidence. |
+
+`defineAgentEval()` also exposes `improve()` when the same agent, cases, judge, and baseline should share configuration.
+Use direct [campaign controls](./docs/eval-surface-map.md) for scheduling, durable caches, model matrices, or custom release rules.
+The [example index](./examples/README.md) covers fixtures, trace intake, code verification, replay, and training-data exports.
+
+## Make automated improvement accountable
+
+Use reusable evaluations for development feedback.
+For a direct edit, compare the baseline and candidate on the same cases.
+Claims, evaluator audits, and final-evidence tracking are optional.
+Add stronger controls when a result must support performance on new tasks or an adaptive release decision.
+
+1. Pass a `claim` describing the population, sampling frame, and independent unit to the comparison.
+   Declare `minimumEffect` when the decision concerns a useful improvement.
+2. When introducing an evaluator, check known good and known bad controls with `auditEvaluator()`.
+3. Give search separate training and selection cases.
+4. For fresh confirmation, supply `finalEvidence` with a shared ledger, request ID, and evaluator digest.
+   This reserves final units before search and records exposure before measurement.
+5. Inspect the final comparison, gate contributions, exclusions, uncertainty, cost, and search history before releasing.
+
+Repeated attempts on one task do not create new independent tasks.
+The top-level `claim` controls unit aggregation for reusable comparisons.
+Power checks assess the declared minimum effect.
+Optional `finalEvidence` binds fresh confirmation to that claim and refuses reused final units across campaigns sharing the ledger.
+
+The host must enforce access isolation and author/auditor separation.
+A digest records identity; it cannot prove secrecy or that a benchmark represents future users.
+Custom gates remain responsible for their decision rules.
+See [evaluation integrity](./docs/evaluation-integrity.md) for the complete API and its boundaries.
+
+These controls check the evidence behind a result.
+They do not establish that an optimizer beats a direct edit or simple search.
+The [historical evidence audit](./docs/design/self-improvement-evidence-audit.md) records prior gains, failed transfer, and missing comparisons.
+
+Set `searchHistoryPolicy: 'require-complete'` when every attempted search slot must be accounted for before final evidence is exposed.
+The [search-history receipt](./docs/search-history-receipts.md) binds the planned denominator to Eval's existing search ledger.
+
+A `gateDecision` is `ship`, `hold`, `need_more_work`, `model_ceiling`, or `arch_ceiling`.
+Gate contributions distinguish missing evidence from measured failures and successful checks.
+[Concepts](./docs/concepts.md) explains these decisions and how gates compose.
+
+## Configure model calls
+
+Pass a `ChatClient` to model judges, analysts, and adapters.
+Eval obtains credentials from the values you supply; it does not search your environment.
 
 ```ts
-import { createChatClient } from '@tangle-network/agent-eval'
+import { createChatClient } from '@tangle-network/agent-eval/contract'
 
 const chat = createChatClient({
-  transport: 'custom',
-  defaultModel: 'openai/gpt-4.1',
-  maximumAttempts: 3,
-  chat: async (request, opts) => myProviderClient(request, opts),
+  transport: 'openai-compatible',
+  baseUrl: 'https://router.example/v1',
+  apiKey: process.env.MY_ROUTER_KEY,
+  defaultModel: process.env.EVAL_MODEL_ID,
 })
 ```
 
-Or name an OpenAI-compatible endpoint and hand over a credential as values, and Agent Eval drives `POST {baseUrl}/chat/completions` for you:
+Use your deployed model identifier and preserve the returned `servedModel` identity and cost receipt.
+For an existing SDK, use `transport: 'custom'` with your `chat` callback and an explicit `maximumAttempts`.
+Agent Runtime callers can bind `profileChatClient()` from `@tangle-network/agent-runtime/kernel`.
+Eval has no dependency on Runtime.
 
-```ts
-const chat = createChatClient({
-  transport: 'openai-compatible',
-  baseUrl: 'https://router.example/v1',   // ends at /v1; the path is ours to append
-  apiKey: process.env.MY_ROUTER_KEY,      // or `bearer`, or `authHeader`
-  defaultModel: 'claude-sonnet-4-6',
-})
-```
+Official GEPA, SkillOpt, and DSPy integrations use a Python bridge.
+Their maintained installation instructions and execution contracts are in [campaign proposers](./docs/campaign-proposers.md).
+The [Python client](./clients/python/README.md) and [wire protocol](./docs/wire-protocol.md) support other-language consumers.
+
+## Public imports and evidence
+
+Use `/contract` for a product integration, `/campaign` for execution controls, `/experiment` for registered decisions, and `/meta-eval` for evaluator checks.
+Root `Scenario`, `JudgeScore`, and `GateDecision` are the same types as `/contract`.
+Product judging retains the explicit root names `ProductScenario` and `DimensionJudgeScore` beside its functions.
+`HeldOutGate.evaluate()` returns `HeldOutGateDecision`.
+
+Specialist subpaths and their examples are listed in the [surface map](./docs/eval-surface-map.md).
+Current canonical envelopes are required for seals, attestations, and profile identities.
+Retired or incomplete formats fail verification; historical reports retain their recorded identities.
 
-Prefer the second over hand-rolling a fetch loop. It carries the retry, degrade, and — load-bearing — the `servedModel` echo that `assertServedModel` and `assertCrossFamilyServed` read; a transport that omits that field makes both checks report `unreported`, so the cross-vendor rules they enforce measure nothing. `baseUrl` and one credential form are required arguments with no default and no fallback: a half-configured client is refused at construction rather than reaching an endpoint you did not name.
-
-On Agent Runtime, `profileChatClient({ profile, executor, context })` from `@tangle-network/agent-runtime/kernel` is that transport: every call runs one exact `AgentProfile` and reports its measured usage, retries, and served model identity.
-Use `sandbox-sdk` for Sandbox and `mock` in tests.
-A custom adapter must return a `ChatResponse` and declare `maximumAttempts` before a capped cost account can dispatch it.
-
-`ChatResponse` carries the whole execution record across that boundary: the served model id, measured input/output/reasoning/cached tokens, billed USD or an explicit unknown, the finish reason, and the per-token log probabilities the expectation judge scores on.
-
-The official GEPA and SkillOpt optimizers run through a Python bridge.
-Install commands, version pins, and the reason for each pin:
-[GEPA](./docs/campaign-proposers.md#install-official-gepa),
-[SkillOpt](./docs/campaign-proposers.md#install-official-skillopt),
-and [DSPy](./docs/campaign-proposers.md#use-official-dspy-optimizers).
-
-## Entry Points
-
-| Import | Use |
-|---|---|
-| `@tangle-network/agent-eval/contract` | Define an evaluation, run it, improve it, and analyze existing runs. |
-| `@tangle-network/agent-eval/campaign` | Campaigns, optimization methods, comparisons, storage, and release rules. |
-| `@tangle-network/agent-eval/experiment` | Experiments as sealed objects: registered rules, funnels, estimands, refusals. |
-| `@tangle-network/agent-eval/analyst` | Built-in and custom trace analysts, labeled comparison, costs, and reports. |
-| `@tangle-network/agent-eval/trace-repair` | Grade one analyst finding by executing the repair it proposes. |
-| `@tangle-network/agent-eval/trajectory-replay` | Re-execute a recorded shell trajectory and check whether its failure reproduces. |
-| `@tangle-network/agent-eval/traces` | Store, replay, and inspect structured traces. |
-| `@tangle-network/agent-eval/reporting` | Statistical comparisons and report rendering. |
-| `@tangle-network/agent-eval/supervisor-run` | Read recursive run directories without collapsing missing measurements to zero; `agent-eval supervisor-run report <runDir>` prints one. |
-| `@tangle-network/agent-eval/meta-eval` | Measure the grader itself: judge calibration, sentinels, and seeded known-wrong plants. |
-| `@tangle-network/agent-eval/profile-cell` | Create and validate portable agent-profile identities. |
-| `@tangle-network/agent-eval/ledger-core` | Append-only hash-chained journal with idempotent append and chain verification. |
-| `@tangle-network/agent-eval/benchmarks` | Benchmark adapters and retrieval metrics. |
-| `@tangle-network/agent-eval/rl` | Export rewards, preferences, and training rows. |
-| `@tangle-network/agent-eval/wire` | HTTP and RPC schemas for other languages. |
-| `@tangle-network/agent-eval/adapters/http` | Run campaign cells on remote workers over HTTP. |
-
-Use the root import for common primitives.
-Use a subpath when you want an explicit capability boundary.
-
-## Documentation
-
-| Question | Read |
-|---|---|
-| What do these words mean? | [`docs/concepts.md`](./docs/concepts.md) |
-| Why does this package exist, and where is it going? | [`docs/charter.md`](./docs/charter.md) |
-| Which `run*` function do I want? | [`docs/eval-surface-map.md`](./docs/eval-surface-map.md) |
-| How do I choose a candidate-generation method? | [`docs/campaign-proposers.md`](./docs/campaign-proposers.md) |
-| What is in an `InsightReport`? | [`docs/insight-report.md`](./docs/insight-report.md) |
-| How do I register an experiment as a sealed object? | [`docs/experiment.md`](./docs/experiment.md) |
-| How is something certified without an answer key? | [`docs/verification-strategies.md`](./docs/verification-strategies.md) |
-| Where does every verifier land its result? | [`docs/verdicts.md`](./docs/verdicts.md) |
-| Does the grader catch a claim that is known to be wrong? | [`docs/plants.md`](./docs/plants.md) |
-| How do I turn a coding-agent session log into runs? | [`docs/code-agent-intake.md`](./docs/code-agent-intake.md) |
-| How do I score a string from another language? | [`docs/wire-protocol.md`](./docs/wire-protocol.md) |
-
-The [example index](./examples/README.md) lists every runnable example.
+Published measurements live in the [evidence registry](./evidence/README.md).
+The [benchmark-book review](./docs/design/mlbenchmarks-book-review.md) records the source analysis and reproduced defects behind these integrity changes.
+[The charter](./docs/charter.md) defines package ownership and the remaining research boundaries.
 
 ## Development
 
 ```sh
 pnpm install
+pnpm build
 pnpm typecheck
 pnpm typecheck:examples
+pnpm typecheck:scripts
+pnpm lint
 pnpm test
-pnpm build
+pnpm verify:package
 ```
 
-Python compatibility tests use the locked dependencies:
-
-```sh
-cd clients/python
-uv sync --frozen --extra dev --group gepa-release
-AGENT_EVAL_EXPECT_GEPA_RELEASE=1 \
-  uv run --frozen --extra dev --group gepa-release \
-  pytest tests/test_gepa_release_compatibility.py tests/test_gepa_bridge.py
-
-uv sync --frozen --extra dev --group skillopt-source --group gepa-source
-uv run --frozen pytest
-
-uv sync --frozen --extra dev --extra dspy
-uv run --frozen pytest tests/test_dspy_metric.py
-```
+Build before checking examples because they resolve the package's generated declarations.
+The [Python development guide](./clients/python/README.md#development) gives the locked commands for each optimizer environment.
 
 ## License
 
 MIT.
-
-
-## Supervisor-run resource receipts
-
-The `/supervisor-run` reader preserves named-resource measurements in `economics.resourceRecords`.
-Each record identifies its node and source within the normalized journal or terminal result.
-Journal row indices refer to parsed rows after reader normalization, not original file line numbers.
-The Markdown report renders each resource name, unit, amount, and completeness flag.
-Comparison cells retain those same records without combining them.
-
-A false `known` flag means the amount is a recorded subtotal, not complete usage.
-Missing maps, explicit empty maps, and invalid fields remain distinct from measured zero.
-Parent settlements and terminal results can include child usage, so these records are not additive totals.
-The reporter reads evidence; it does not enforce budgets or infer missing measurements.

package/dist/adapters/http.d.ts

@@ -1,5 +1,5 @@
-import { R as Scenario, d as DispatchContext, f as DispatchFn } from "../types-C34V4Vto.js";
-import "../index-DxNYmx4a.js";
+import { R as Scenario, d as DispatchContext, f as DispatchFn } from "../types-CS0qk_Yp.js";
+import "../index-DoykkxW0.js";
 //#region src/adapters/http.d.ts
 interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
   /** Static endpoint URL. Mutually exclusive with `resolveUrl`. */

package/dist/{agent-profile-B7yErX0q.d.ts → agent-profile-CivaSsSy.d.ts}

@@ -1,7 +1,7 @@
 import { b as CustomTokenPricing, g as CostReceiptInput } from "./cost-ledger-DbQdN3nO.js";
-import { D as TraceAnalysisStore, c as AnalystRunInputs, f as AnalystUsageReceipt, i as AnalystFinding, p as EvidenceRef } from "./types-DzuaM493.js";
-import { h as ChatResponse, m as ChatRequest } from "./types-gvRsyJLh.js";
-import { c as RegistryRunOpts, n as AnalystRegistry } from "./registry-ByVld1-5.js";
+import { D as TraceAnalysisStore, c as AnalystRunInputs, f as AnalystUsageReceipt, i as AnalystFinding, p as EvidenceRef } from "./types-D7gEdPoQ.js";
+import { C as ChatResponse, S as ChatRequest } from "./types-CBbLtr2J.js";
+import { c as RegistryRunOpts, n as AnalystRegistry } from "./registry-BRbB6Y0v.js";
 import { AgentProfile, AgentProfile as AgentProfile$1, HarnessType, HarnessType as HarnessType$1 } from "@tangle-network/agent-interface";
 //#region src/campaign/external-optimizer-contracts.d.ts
 interface ExternalOptimizerProcessLimits {
@@ -485,4 +485,4 @@ declare function agentProfileId(profile: AgentProfile): string;
 declare function agentProfileHash(profile: AgentProfile): string;
 //#endregion
 export { runAnalystBenchmark as A, ExternalOptimizerModelBudget as B, AnalystEvidenceResolutionError as C, AnalystLatencyDistribution as D, AnalystIssueExpectation as E, ExternalOptimizerCallbackLimits as F, ExternalOptimizerProcessLimits as G, ExternalOptimizerModelCallRequest as H, ExternalOptimizerChatRequest as I, ExternalOptimizerWireCounts as J, ExternalOptimizerResumeMode as K, ExternalOptimizerEndpointFormat as L, scoreAnalystFindings as M, DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS as N, RunAnalystBenchmarkOptions as O, DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS as P, resolveExternalOptimizerProcessLimits as Q, ExternalOptimizerEvaluationObservation as R, AnalystEvidenceResolution as S, AnalystFindingScore as T, ExternalOptimizerModelCallResult as U, ExternalOptimizerModelCall as V, ExternalOptimizerModelExecutionObservation as W, ExternalTextEvaluationRequest as X, ExternalTextCandidate as Y, resolveExternalOptimizerCallbackLimits as Z, AnalystBenchmarkProvenance as _, ProfileAxisSpec as a, AnalystBenchmarkSummary as b, expandProfileAxes as c, AnalystBenchmarkDatasetRef as d, AnalystBenchmarkDescriptor as f, AnalystBenchmarkOutput as g, AnalystBenchmarkObservation as h, HarnessType$1 as i, traceStoreEvidenceResolver as j, registryBenchmarkRunner as k, harnessAxisOf as l, AnalystBenchmarkLabelState as m, CODING_HARNESSES as n, agentProfileHash as o, AnalystBenchmarkError as p, ExternalOptimizerRunnerCommand as q, HARNESS_NATIVE_MODEL as r, agentProfileId as s, AgentProfile$1 as t, AnalystBenchmarkCase as u, AnalystBenchmarkResult as v, AnalystEvidenceResolver as w, AnalystEvidenceExpectation as x, AnalystBenchmarkRunner as y, ExternalOptimizerEvaluationRefusalReason as z };
-//# sourceMappingURL=agent-profile-B7yErX0q.d.ts.map
+//# sourceMappingURL=agent-profile-CivaSsSy.d.ts.map

package/dist/{agent-profile-B7yErX0q.d.ts.map → agent-profile-CivaSsSy.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"agent-profile-B7yErX0q.d.ts","names":[],"sources":["../src/campaign/external-optimizer-contracts.ts","../src/analyst/benchmark-scoring.ts","../src/analyst/benchmark.ts","../src/agent-profile.ts"],"mappings":"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"}
+{"version":3,"file":"agent-profile-CivaSsSy.d.ts","names":[],"sources":["../src/campaign/external-optimizer-contracts.ts","../src/analyst/benchmark-scoring.ts","../src/analyst/benchmark.ts","../src/agent-profile.ts"],"mappings":"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"}

package/dist/{agent-profile-cell-0gSi5ffD.js → agent-profile-cell-Cv6UA-W_.js}

@@ -1,6 +1,5 @@
 import { s as ValidationError } from "./errors-Dngq5h35.js";
-import { a as hashCanonical, r as canonicalString } from "./canonical-DPyQ_rpt.js";
-import { createHash } from "node:crypto";
+import { a as hashCanonical } from "./canonical-DPyQ_rpt.js";
 //#region src/pre-registration.ts
 /**
 * Pre-registered hypotheses — declare what you're testing BEFORE the
@@ -12,10 +11,8 @@ import { createHash } from "node:crypto";
 * evaluate the manifest against observed results — the library refuses
 * to let you re-interpret a different metric as the declared one.
 *
-* A signed manifest is a portable record: it is written once and verified
-* later, possibly by a different release. `algo` names the digest scheme it
-* was signed under, and verification selects the encoder by that field, so a
-* manifest signed by an earlier release still verifies.
+* A signed manifest carries its required digest scheme. Verification accepts
+* only RFC 8785 canonical JSON, using the same encoder as every new identity.
 */
 /**
 * SHA-256 hex (full 64 chars) over the RFC 8785 canonical JSON encoding of
@@ -36,31 +33,13 @@ async function hashJson(obj) {
 	return hashCanonical(obj).slice(7);
 }
 /**
-* Key-sorted `JSON.stringify` digest. Private and read-only: it exists so a
-* manifest signed under `'sha256-content'` still verifies, and nothing that
-* WRITES a digest may call it.
-*/
-function legacyContentDigest(value) {
-	return createHash("sha256").update(JSON.stringify(sortKeysDeep$1(value)), "utf8").digest("hex");
-}
-function sortKeysDeep$1(value) {
-	if (value === null || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map(sortKeysDeep$1);
-	const out = {};
-	for (const key of Object.keys(value).sort()) out[key] = sortKeysDeep$1(value[key]);
-	return out;
-}
-/**
-* Digest of a manifest under its own declared scheme, with `contentHash` and
-* `algo` stripped. Synchronous, so a caller that must fail before consuming an
-* observation does not have to await. Throws on an `algo` this release does
-* not know — an unverifiable manifest must not read as a valid one.
+* Digest a manifest after validating its scheme, excluding `contentHash` and
+* `algo`. This synchronous check can refuse a manifest before consuming data.
 */
 function manifestContentDigest(manifest) {
 	const { contentHash: _contentHash, algo, ...rest } = manifest;
-	if (algo === void 0 || algo === "sha256-content") return legacyContentDigest(rest);
-	if (algo === "sha256-rfc8785") return createHash("sha256").update(canonicalString(rest), "utf8").digest("hex");
-	throw new Error(`pre-registration: unrecognized manifest hash algo '${String(algo)}'`);
+	if (algo !== "sha256-rfc8785") throw new Error(`pre-registration: unsupported manifest hash algo '${String(algo)}'`);
+	return hashCanonical(rest).slice(7);
 }
 /**
 * Sign a manifest with a SHA-256 content hash over its RFC 8785 canonical
@@ -83,14 +62,18 @@ async function signManifest(m) {
 * the manifest itself declares.
 */
 async function verifyManifest(m) {
-	return manifestContentDigest(m) === m.contentHash;
+	try {
+		return manifestContentDigest(m) === m.contentHash;
+	} catch {
+		return false;
+	}
 }
 /**
 * Evaluate a pre-registered hypothesis against observed results.
 * Mechanical — no re-interpretation permitted.
 */
 async function evaluateHypothesis(manifest, observed) {
-	if (!await verifyManifest(manifest)) throw new Error("evaluateHypothesis: manifest content hash mismatch (tampered)");
+	if (!await verifyManifest(manifest)) throw new Error("evaluateHypothesis: unsupported manifest hash scheme or content hash mismatch");
 	const reasons = [];
 	if (!(manifest.direction === "increase" ? observed.effect > 0 : observed.effect < 0)) reasons.push("wrong_direction");
 	if (Math.abs(observed.effect) < manifest.minEffect) reasons.push("effect_too_small");
@@ -115,14 +98,9 @@ var AgentProfileCellValidationError = class extends ValidationError {
 	}
 };
 const SHA256_HEX = /^[0-9a-f]{64}$/;
-/**
-* A cell id names the digest scheme that produced it. `sha256-rfc8785` is what
-* {@link buildAgentProfileCell} mints; the bare `sha256` form is read-only,
-* carried by cells built under an earlier release, and still verifies.
-*/
-const CELL_ID = /^agent-profile-cell:sha256(?:-rfc8785)?:[0-9a-f]{64}$/;
+/** A cell id carries the canonical digest scheme required for verification. */
+const CELL_ID = /^agent-profile-cell:sha256-rfc8785:[0-9a-f]{64}$/;
 const CELL_ID_PREFIX = "agent-profile-cell:sha256-rfc8785:";
-const LEGACY_CELL_ID_PREFIX = "agent-profile-cell:sha256:";
 async function buildAgentProfileCell(input) {
 	const material = await normalizeAgentProfileCellInput(input);
 	const cellId = `${CELL_ID_PREFIX}${await hashJson(material)}`;
@@ -137,34 +115,19 @@ function agentProfileCellHashMaterial(cell) {
 }
 /**
 * Verify an `AgentProfileCell`'s `cellId` matches the sha256 of its hash-material
-* fields, confirming the record has not been tampered with. The id names its own
-* digest scheme, so a cell minted by an earlier release verifies under that scheme.
+* fields, confirming the record has not been tampered with. Unsupported digest
+* schemes are refused before comparing the material.
 */
 async function verifyAgentProfileCell(cell) {
 	validateAgentProfileCell(cell);
 	const material = agentProfileCellHashMaterial(cell);
-	if (cell.cellId.startsWith(CELL_ID_PREFIX)) return cell.cellId === `${CELL_ID_PREFIX}${await hashJson(material)}`;
-	return cell.cellId === `${LEGACY_CELL_ID_PREFIX}${legacyCellDigest(material)}`;
-}
-/**
-* Key-sorted `JSON.stringify` digest. Private and read-only: it verifies a cell
-* id minted before the RFC 8785 scheme, and no path that MINTS an id calls it.
-*/
-function legacyCellDigest(value) {
-	return createHash("sha256").update(JSON.stringify(sortKeysDeep(value)), "utf8").digest("hex");
-}
-function sortKeysDeep(value) {
-	if (value === null || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map(sortKeysDeep);
-	const out = {};
-	for (const key of Object.keys(value).sort()) out[key] = sortKeysDeep(value[key]);
-	return out;
+	return cell.cellId === `${CELL_ID_PREFIX}${await hashJson(material)}`;
 }
 function validateAgentProfileCell(input) {
 	if (input === null || typeof input !== "object") throw new AgentProfileCellValidationError("expected object");
 	const obj = input;
 	expectLiteral(obj.schemaVersion, "agent-profile-cell/v1", "schemaVersion");
-	if (typeof obj.cellId !== "string" || !CELL_ID.test(obj.cellId)) throw new AgentProfileCellValidationError("cellId must match agent-profile-cell:sha256:<64 lowercase hex chars>", "cellId");
+	if (typeof obj.cellId !== "string" || !CELL_ID.test(obj.cellId)) throw new AgentProfileCellValidationError("cellId must match agent-profile-cell:sha256-rfc8785:<64 lowercase hex chars>", "cellId");
 	expectString(obj.profileId, "profileId");
 	validateSource(obj.sourceProfile, "sourceProfile");
 	if (obj.harness !== void 0) validateHarness(obj.harness, "harness");
@@ -371,4 +334,4 @@ async function buildAgentInterfaceProfileCell(profile, input) {
 //#endregion
 export { verifyManifest as _, assertRunAgentProfileCell as a, groupRunsByAgentProfileCell as c, validateAgentProfileCell as d, verifyAgentProfileCell as f, signManifest as g, manifestContentDigest as h, agentProfileCellKey as i, requireAgentProfileCell as l, hashJson as m, AgentProfileCellValidationError as n, buildAgentInterfaceProfileCell as o, evaluateHypothesis as p, agentProfileCellHashMaterial as r, buildAgentProfileCell as s, AGENT_PROFILE_KINDS as t, toAgentProfileJson as u };
 
-//# sourceMappingURL=agent-profile-cell-0gSi5ffD.js.map
+//# sourceMappingURL=agent-profile-cell-Cv6UA-W_.js.map