@tangle-network/agent-eval 0.179.0 → 0.181.0

package/docs/outcome-validity.md

@@ -0,0 +1,182 @@
+# Connect rubric scores to deployment outcomes
+
+`rubricPredictiveValidity()` measures associations between rubric scores and observations from deployment.
+Declare the desired direction for each outcome before reading the results.
+Define rubric scores so higher values mean better evaluated behavior.
+
+```ts
+import {
+  InMemoryOutcomeStore,
+  rubricPredictiveValidity,
+  type DeploymentOutcome,
+  type OutcomeMetricSpec,
+} from '@tangle-network/agent-eval/meta-eval'
+import type { RunRecord } from '@tangle-network/agent-eval'
+
+async function assessOutcomes(runs: RunRecord[], observations: DeploymentOutcome[]) {
+  const outcomes = new InMemoryOutcomeStore()
+  for (const observation of observations) await outcomes.append(observation)
+  const metrics: OutcomeMetricSpec[] = [
+    { id: 'success_rate', direction: 'higher-is-better' },
+    { id: 'failure_rate', direction: 'lower-is-better' },
+  ]
+
+  return rubricPredictiveValidity({
+    runs,
+    outcomes,
+    outcomeMetrics: metrics,
+    rubrics: ['task_quality'],
+  })
+}
+```
+
+Populate `RunRecord.outcome.raw.task_quality` with the captured rubric score.
+Append deployment observations with the same `runId` and exact outcome metric keys.
+The store accepts finite numbers, including zero.
+Omit an unmeasured metric instead of replacing it with zero.
+
+An observation records when and where its outcomes were captured:
+
+```ts
+const observation: DeploymentOutcome = {
+  runId: 'support-run-42',
+  capturedAt: Date.now(),
+  metrics: { success_rate: 1, failure_rate: 0 },
+  labels: { cohort: 'support' },
+  source: 'resolution-events-v1',
+}
+```
+
+`capturedAt` uses epoch milliseconds.
+The matching run supplies the rubric score; this observation supplies the measured deployment outcome.
+
+The default reduction selects the latest finite observation of each requested metric.
+A newer row containing another metric cannot supply its value or erase an older observation.
+The `mean` and `max` reductions operate on that metric alone.
+
+## Read the report
+
+| Field | Interpretation |
+|---|---|
+| `pearson`, `spearman` | Association with the recorded outcome, retaining its original sign. |
+| `alignedPearson`, `alignedSpearman` | Positive means higher rubric scores associate with better outcomes. |
+| `pearsonCi95`, `spearmanCi95` | Bootstrap intervals for the raw associations. |
+| `alignedSpearmanCi95` | Spearman interval after applying the declared outcome direction. |
+| `verdict` | `aligned` at aligned Spearman ≥ 0.4; `inverse` at ≤ −0.4; otherwise `weak`. |
+| `n` | Finite joined run observations for this rubric and outcome. |
+| `excludedPairs` | Unestimated pairs, their observation counts, and the reason for exclusion. |
+| `rubricsWithoutData` | Declared rubrics with no finite score in the supplied runs. |
+
+A rubric can correlate negatively with failure rate and still receive `aligned`.
+The same negative correlation with success rate receives `inverse`.
+These labels describe association strength and direction.
+They do not grant release authority or establish that changing a rubric weight will improve outcomes.
+
+Pairs require eight observations by default.
+`minSamples` can set another integer of at least three.
+Insufficient observations and constant scores or outcomes remain explicit exclusions.
+Constant observations cannot establish a perfect predictor.
+Intervals remain `null` when no bootstrap resample has an estimable correlation.
+
+`joinedSamples + skippedRuns` equals the supplied run count.
+A run is joined when at least one finite score and outcome pair exists.
+It remains joined even if that pair has too few observations for estimation.
+Duplicate run IDs are rejected.
+
+Each run is an independent bootstrap observation.
+Repeated observations from the same person or task can violate that assumption.
+Aggregate at the independent unit or use a study with an appropriate grouped estimator.
+
+`ranked` selects each rubric's highest direction-aligned association across the declared outcomes.
+This ordering is exploratory and can conceal conflicts among outcomes.
+Inspect all `pairs` and use a target chosen before analysis for an automated recommendation.
+Confirm any proposed change with fresh evidence and fixed scoring rules.
+
+## Propose an experiment against one target
+
+```ts
+import { PredictiveValidityResearcher } from '@tangle-network/agent-eval/rl'
+import { InMemoryOutcomeStore } from '@tangle-network/agent-eval/meta-eval'
+
+const outcomes = new InMemoryOutcomeStore()
+const researcher = new PredictiveValidityResearcher({
+  outcomes,
+  targetOutcome: { id: 'success_rate', direction: 'higher-is-better' },
+  rubrics: ['task_quality'],
+})
+```
+
+Supply observed outcomes before calling `runValidityCheck(runs)`.
+Pass the resulting failure groups to `proposeChange(failures)`.
+The researcher uses its declared target even if another outcome has a stronger association.
+It proposes increased-weight experiments for aligned associations and reversal or replacement experiments for inverse associations.
+Both require an aligned Spearman interval that excludes zero.
+Weak or uncertain associations produce requests for calibration evidence.
+Missing estimates produce requests for more outcome observations.
+
+The proposals contain their association, interval, sample count, and target direction.
+They contain no predicted improvement because a correlation does not identify a causal treatment effect.
+`applyChange()` appends proposals to a plan.
+`evaluateChange()` declines promotion because the caller owns experiment execution.
+
+`runRLCampaign()` accepts the same outcome specifications through `outcomeMetrics` when `outcomeStore` is supplied.
+Supply both options together; incomplete or empty declarations fail before campaign execution.
+Its summary reports direction-aligned association and preserves missing estimates.
+The target declaration remains fixed while the campaign runs.
+
+The researcher copies its target declaration, rubric list, and cached reports.
+Changing callback arguments, returned reports, or proposal payloads cannot rewrite its cached evidence.
+
+## Store observations without losing failures
+
+`InMemoryOutcomeStore` and `FileSystemOutcomeStore` copy observations at ingestion and retrieval.
+Changing a caller's metric or label object cannot rewrite stored evidence.
+The filesystem store rereads observations so another instance's later writes remain visible.
+Use one writer per directory; operations on that writer are serialized.
+
+A nonexistent directory is an empty store.
+An unreadable file, malformed JSON, or invalid outcome record throws `OutcomeStoreError`.
+The error carries its operation, path, source line when available, and original cause.
+Read errors never become empty studies or partial successful results.
+Repair the source and retry the read.
+
+For trace data, `correlationStudy()` accepts outcome names and reports descriptive associations without a desired direction.
+It shares the metric reduction, bootstrap, and exclusion behavior.
+It excludes observations captured before the run started.
+`maxCaptureLagMs` optionally bounds the elapsed time from run start through outcome capture, including both endpoints.
+
+## Inspect calibration by score range
+
+Use `calibrationFromPairs()` when scores and outcomes are already joined.
+It accepts readonly observations directly.
+
+```ts
+import { calibrationFromPairs } from '@tangle-network/agent-eval/meta-eval'
+
+const calibration = calibrationFromPairs([
+  { evalScore: 1, outcome: 0 },
+  { evalScore: 1, outcome: 0 },
+], 'predicted-success', 'observed-success')
+
+console.log(calibration?.ece) // 1: confident predictions, observed failures.
+```
+
+Direct input rejects nonfinite pairs with the offending index.
+It does not silently discard them from the denominator.
+`calibrationCurve()` performs the join for trace and outcome stores using the latest finite observation of the named outcome metric.
+It reports each bin's count, mean score, mean outcome, and absolute gap.
+`ece` weights each bin's gap by its share of the finite joined observations.
+Both quantities must use comparable numerical scales for this difference to measure calibration.
+
+The `range` option clips scores before binning and retains every joined observation.
+The reported calibration error then describes the clipped scores; retain that transformation with the result.
+Constant scores form one bin, so a consistently wrong predictor still receives a measured calibration error.
+Equal-frequency binning produces the requested number of bins, capped by the observation count.
+Bin counts differ by at most one, except when all scores share one value.
+Equal-width binning omits empty bins.
+On either path, bin counts sum to the reported `n`.
+
+Fewer than two finite pairs returns `null`.
+Both entry points validate metric identities, binning options, and range bounds.
+Invalid requests fail even when no evidence is available.
+The store entry point validates before reading evidence.

package/docs/product-eval-adoption.md

@@ -152,8 +152,7 @@ set with a signed note.
 
 ## Optimization
 
-Use `runImprovementLoop()` when the system is a multi-step agent, not a
-single prompt.
+Use `runImprovementLoop()` when a `SurfaceProposer` supplies candidates for Agent Eval's search loop.
 
 Good optimization targets:
 

package/docs/research-report-methodology.md

@@ -60,14 +60,14 @@ In order: first match wins:
 
 | Quantity | Function | Source file |
 |---|---|---|
-| Marginal CI on score mean | `confidenceInterval` | `statistics.ts` |
-| Paired Cohen's dz vs comparator | `pairedCohensDz` | `statistics.ts` |
-| Wilcoxon signed-rank (paired), exact at n ≤ 20 | `wilcoxonSignedRank` | `statistics.ts` |
-| BH-FDR q-values | `benjaminiHochberg` | `statistics.ts` |
-| Paired bootstrap CI on median delta | `pairedBootstrap` | `statistics.ts` |
-| Smallest p a rank-test design can produce | `pFloor` on the result | `statistics.ts` |
+| Marginal CI on score mean | `confidenceInterval` | [`descriptive.ts`](../src/statistics/descriptive.ts) |
+| Paired Cohen's dz vs comparator | `pairedCohensDz` | [`effect-sizes.ts`](../src/statistics/effect-sizes.ts) |
+| Wilcoxon signed-rank (paired), exact at n ≤ 20 | `wilcoxonSignedRank` | [`rank-tests.ts`](../src/statistics/rank-tests.ts) |
+| BH-FDR q-values | `benjaminiHochberg` | [`multiplicity.ts`](../src/statistics/multiplicity.ts) |
+| Paired bootstrap CI on median delta | `pairedBootstrap` | [`paired-tests.ts`](../src/statistics/paired-tests.ts) |
+| Smallest p a rank-test design can produce | `pFloor` on the result | [`rank-tests.ts`](../src/statistics/rank-tests.ts) |
 | Bayesian-bootstrap Pr(Δ>0), Pr(Δ∈ROPE) | `bayesianBootstrapMeanSamples` | `summary-report.ts` (private) |
-| Minimum detectable paired effect | `pairedMde` | `statistics.ts` |
+| Minimum detectable paired effect | `pairedMde` | [`power-and-mde.ts`](../src/statistics/power-and-mde.ts) |
 | Run fingerprint | `hashJson(...)` | `pre-registration.ts` |
 
 The Pr(Δ>0) and Pr(Δ∈ROPE) summaries use Rubin's Bayesian bootstrap.

package/docs/search-history-receipts.md

@@ -222,3 +222,11 @@ Receipts describe measurements; they do not override the release gate or replace
 `createCampaignEvidenceReceipt` on `/experiment` provides the same binding for other complete campaign consumers.
 Changing an output changes its output digest; changing a judge result changes its measurement digest.
 The final receipt retains caller authority, including `candidate-self-report`, without upgrading it.
+
+## Implementation ownership
+
+`src/campaign/search-ledger.ts` owns validation, canonical event normalization, and composition with the shared ledger journal.
+`search-ledger-projector.ts` owns campaign replay invariants and audit projection.
+`search-ledger-types.ts` defines the shared data contracts, reexported through the existing facade.
+`search-ledger-ordering.ts` shares artifact identity and deterministic string ordering between normalization and replay.
+The journal in `src/ledger-core` owns hashing, locking, durable appends, and chain verification.

package/docs/statistical-evidence.md

@@ -0,0 +1,129 @@
+# Statistical evidence
+
+Repeated runs measure execution variation on the cases you supplied.
+A claim about new cases also needs independent observations from its target population.
+Repeating one incident 100 times supplies one incident, even when every execution has a distinct identifier.
+
+## Declare the independent unit
+
+Pass `independentUnitByScenarioId` to `defaultProductionGate`, `heldoutSignificance`, or `dimensionRegressions` when scenarios share a source.
+The map assigns each scenario to the incident, document, task family, or other unit sampled independently.
+Choose this assignment before examining scores.
+
+```ts
+import { defaultProductionGate } from '@tangle-network/agent-eval/campaign'
+
+const holdoutScenarios = [
+  { id: 'incident:17:original', kind: 'support' },
+  { id: 'incident:17:paraphrase', kind: 'support' },
+  { id: 'incident:28:original', kind: 'support' },
+]
+
+const gate = defaultProductionGate({
+  holdoutScenarios,
+  independentUnitByScenarioId: new Map([
+    ['incident:17:original', 'incident-17'],
+    ['incident:17:paraphrase', 'incident-17'],
+    ['incident:28:original', 'incident-28'],
+  ]),
+  deltaThreshold: 0.05,
+  criticalDimensions: ['factualAccuracy'],
+})
+```
+
+This example has two independent units and cannot meet its observation minimum.
+More repetitions of these scenarios will not change that count.
+The default gate copies the map when it is constructed.
+Later mutations cannot change the grouping used by that gate.
+
+Pairing precedes aggregation.
+Candidate and baseline must contain the same full cell identifiers and the same selected judges within each cell.
+The last numeric suffix identifies a repetition, so colons within scenario identifiers remain valid.
+The implementation averages matched cells within each unit, then gives every unit equal weight.
+It refuses asymmetric cells, asymmetric selected judges, duplicate cells, non-finite scores, and missing unit assignments.
+
+Reports distinguish the following counts:
+
+| Field | Meaning |
+|---|---|
+| `n` | Paired observation units used for inference |
+| `pairedCellN` | Matched execution cells before grouping |
+| `observationUnit` | `registered` when a supplied map defines units; `cell` on an ungrouped fixed-roster path |
+| `unitIds` | The units represented in a held-out significance result |
+
+Without a map, fixed-roster significance uses execution cells as observations.
+Its uncertainty concerns independently sampled execution outcomes conditional on that roster.
+It does not establish generalization to new incidents or task families.
+Identifiers and aggregation do not establish independence; the sampling design must justify it.
+
+## Read the interval that decided
+
+`heldoutSignificance().decision` contains the test, interval, observation minimum, and promotion decision.
+Pass/fail scores use the shared paired risk-difference rule.
+Continuous scores use the shared paired bootstrap or its small-sample test.
+`bootstrap` and `medianBootstrap` remain diagnostics when another test decides.
+
+Continuous mean targets require 20 observations for bootstrap eligibility.
+Below that count, a reported exact sign-test diagnostic cannot establish a mean effect.
+Binary outcomes and explicitly requested median targets use their actual confidence-dependent observation minimum.
+The observation minimum establishes estimator eligibility; it does not establish statistical power or representative sampling.
+A zero-width bootstrap interval cannot establish improvement under the shared decision rule.
+
+Required dimensions also need sufficient observations and complete coverage.
+The default gate reports `not_evaluated` when a required dimension lacks enough units or omits matched cells or scenarios.
+`fewRuns`, `missingCellIds`, and `missingScenarioIds` preserve the missing evidence.
+An observed regression can still hold the gate while evidence remains incomplete.
+Passing the regression guard does not certify every safety property of the candidate.
+
+## Sequential decisions require a conditional-mean assumption
+
+`sequentialPairedGate` consumes one observation per scenario by default in `decide()`.
+Its `independentUnitByScenarioId` option groups related scenarios before testing and copies the mapping at construction.
+`maxN` counts these independent units.
+The report preserves both the consumed count `n` and the available counts `pairedN` and `pairedCellN`.
+
+The statistical guarantee requires each next delta's conditional expectation to remain below the registered null boundary.
+Independent sampling with that bound is sufficient.
+Shuffling an exchangeable sequence does not establish the condition.
+One random sign repeated 100 times has only one independent draw.
+After its first observation, later signs reveal no new evidence.
+
+Direct `observe(delta)` callers must perform the required aggregation themselves.
+They must also justify the sampling assumption.
+`sequentialDecide` stops candidate exploration heuristically; candidate selection and reused incumbent scores prevent a general type-I error guarantee.
+The selected candidate still requires fresh held-out evidence.
+
+## Adaptation comparisons pair whole scenarios
+
+`runAdaptationCurve` and `compareAdaptationCurves` are exported from `@tangle-network/agent-eval/rl`.
+Scenarios require explicit, unique `scenarioId` values.
+The runner validates repetitions, the demonstration grid, and finite scores in `[0,1]`.
+
+Comparisons require identical scenario cohorts and identical demonstration grids.
+Missing pairs, duplicate identities, and changing cohorts are errors.
+The comparison computes one area per scenario before applying the existing paired estimators.
+This preserves dependence across demonstration counts.
+Repeated executions improve each scenario mean without increasing the number of independent scenarios.
+
+`perK` intervals describe the curve.
+The paired area decisions determine `a_better`, `b_better`, `inconclusive`, or `insufficient_evidence`.
+Continuous area outcomes require the bootstrap minimum of 20 paired scenarios.
+Binary area outcomes use the shared score-interval rule and can support a decision with fewer observations.
+The deciding interval must remain nondegenerate.
+`inconclusive` does not establish equivalence.
+`firstPassK` describes the first observed crossing and carries no reliability guarantee.
+
+## Perturbation sensitivity is a diagnostic
+
+`runContaminationProbe` reports observed score differences and one global Wilcoxon paired test.
+Use `alpha` for that test's significance threshold.
+Per-item differences carry no p-values or q-values because the probe defines no calibrated item-level sampling null.
+
+The report retains every observed pair and lists `excludedScenarioIds` when a score floor excludes evidence.
+Summaries describe the included population.
+Fewer than four included pairs produce `pairedTest: null` while preserving measured means and medians.
+Zero included pairs produce null summaries.
+
+A significant drop can reflect changed task difficulty, broken perturbations, or contamination.
+`contaminationSuspected` therefore requests investigation; it does not identify the cause.
+The global test also relies on independent pairs and the Wilcoxon assumptions for paired differences.

package/docs/verdicts.md

@@ -1,67 +1,94 @@
-# One verdict vocabulary
+# Verdicts and certifications
 
-Every verification path in this package lands in one type: `DefaultVerdict` (`src/verdict.ts`).
-`valid` answers "did it pass", `score` answers "how well" in [0, 1], `scores` carries the per-dimension breakdown, and `certification` says WHO certified.
+`DefaultVerdict` is the shared base type for validator results.
+Campaign judges return `JudgeScore`, and release gates return `GateResult`; their fields and score scales differ.
+See [release check results](./concepts.md#release-check-results) when interpreting a campaign decision.
 
-A certification is the epistemics a bare `valid` + `score` pair cannot carry.
-A kernel-checked proof and an LLM judge can produce the same `{ valid: true, score: 1 }`; the certification is what tells them apart:
+In `DefaultVerdict`, `valid` reports whether the validator's pass criteria were met, and `score` is its aggregate in [0, 1].
+Optional `scores` and `notes` carry dimensions and explanation.
+Optional `certification` records the verification strategy, checker identity, assumptions, and evidence digest.
+A certification can accompany a failed or incomplete check.
+It does not establish that the result passed or that every required measurement exists.
 
-- `strategy` — which verification-strategy member vouches (the 10-member family with per-member failure modes: [docs/verification-strategies.md](./verification-strategies.md));
-- `checker` — the exact identity that ran, with version and content pins, so the check is re-runnable;
-- `assumptions` — every step the certificate rests on that the checker did NOT verify, named one by one;
-- `evidenceDigest` — sha-256 of the evidence artifact (`certificationEvidenceDigest`).
+The certification fields are:
 
-An absent certification is itself a statement: scored, but nothing vouches.
-No producer fakes one — a closed gate, an unexecuted proof, or an unattested checker yields an uncertified verdict, never an invented certificate.
+- `strategy`: the [verification strategy](./verification-strategies.md), with its documented failure mode.
+- `checker`: a name, version, and optional dependency pins.
+- `assumptions`: the producer's list of steps the checker did not verify.
+- `evidenceDigest`: the evidence identity; `certificationEvidenceDigest()` hashes its JSON-serialized form with canonical JSON and SHA-256.
+
+These fields record the producer's claims.
+Reproduction also requires access to the evidence, checker, dependencies, and execution environment.
+An absent certification means no verification strategy is recorded for that verdict.
 
 ## Producers
 
-Every verifier below returns a `DefaultVerdict` (usually a richer extension of it) with a produced certification.
+These result types extend `DefaultVerdict`.
+Their additional fields distinguish failed checks from incomplete or unmeasured work.
 
-| Verifier | Verdict type | Strategy | Certifies | Assumptions it names |
+| Producer | Result type | Strategy | Scope | Fields to inspect |
 | --- | --- | --- | --- | --- |
-| `MultiLayerVerifier.run` (`src/multi-layer-verifier.ts`) | `VerificationReport` | `composite` | ordered layer pipeline blend | each skipped / errored / timed-out layer |
-| `verifyCompletion` (`src/completion-verifier.ts`) | `CompletionVerdict` | the checker's own (`judge` for the LLM checker, `schema` for token recall) | task completion over produced state | lexical structural stage + the checker's attestation |
-| `evaluateTraceContract` (`src/trace-contracts.ts`) | `ContractVerdict` | `invariant` | LTLf rules over a span sequence | array ordering without timestamps; custom predicate functions |
-| `evaluateOracles` (`src/oracle.ts`) | `OracleReport` | `test` | declarative expected-outcome assertions | — (the oracle set is its own answer key) |
-| `replayVerify` (`src/trajectory-replay/verify.ts`) | `ReplayVerdict` | `replication` | recorded failure reproduced (and fix vanished) under re-execution | unadjudicated prefix steps; truncated prefix; returncode-only signature |
-| `verifyFindings` (`src/trajectory-replay/findings.ts`) | `VerifyFindingsRun` | `replication` | a batch of analyst findings under executed replay | not-replayable findings leave the denominator |
-| `gradeRepairRow` (`src/trace-repair/grade.ts`) | `RepairRowResult` | `test` | a proposed repair against the row's held-out suite (pins: suite + policy digests) | vacuous reproduction gate; prefix divergence |
-| `runEquivalenceCheck` + `equivalenceVerdict` (`src/verification-strategy.ts`, `src/verdict.ts`) | `DefaultVerdict` | the spec's member (`proof-kernel` in the pilot) | two blind formal statements are equivalent | arms self-declare blindness |
-
-Two producers certify conditionally, on purpose:
-
-- `gradeRepairRow` certifies only a `measured` outcome — a funnel gate that closed before the suite ran has nothing to vouch for.
-- `verifyFindings` certifies only when at least one proof executed — a batch where nothing was replayable measured nothing.
-
-## Reading a score out of a judge
-
-A model judge emits one grade per dimension. Discrete grades tie: two candidates that both score `8` carry no ranking signal between them, and a best-of-N selection then picks arbitrarily.
-
-`llmJudge({ scoring })` chooses how the number is read:
-
-| `scoring` | What it reads | Requires |
+| `MultiLayerVerifier.run()` | `VerificationReport` | `composite` | Ordered verification layers | `layers`, `allPass`, and optional `taskScore` |
+| `verifyCompletion()` | `CompletionVerdict` | The supplied checker's strategy | Completion requirements matched against produced state | Requirement evidence, `correct`, and `unmeasured` |
+| `evaluateTraceContract()` | `ContractVerdict` | `invariant` | Temporal rules over recorded spans | Rule results and assumptions about ordering and predicates |
+| `evaluateOracles()` | `OracleReport` | `test` | Declared expected-outcome assertions | `results`, `passCount`, and `failCount` |
+| `replayVerify()` | `ReplayVerdict` | `replication` | Failure reproduction and an optional fix under re-execution | Prefix fidelity, signature matches, and both execution arms |
+| `verifyFindings()` | `VerifyFindingsRun` | `replication` | Analyst findings checked through replay | `executions`, `counts`, and individual verifications |
+| `gradeRepairRow()` | `RepairRowResult` | `test` | A repair against the admitted row's held-out suite | The grade's outcome and funnel evidence |
+| `equivalenceVerdict(record)` | `DefaultVerdict` | The record's strategy | Formal-statement equivalence checked by `runEquivalenceCheck()` | Whether the obligation was proved, refuted, or unresolved |
+
+Certification is conditional for several producers:
+
+- `verifyCompletion()` includes it when the supplied checker provides an attestation.
+  Inspect requirement evidence to see which checks were assessed.
+- `equivalenceVerdict()` includes it for a proved or refuted obligation with an evidence digest.
+  A certified refutation has `valid: false`.
+- `gradeRepairRow()` includes it only for a `measured` grade.
+- `verifyFindings()` includes it only when at least one replay execution ran.
+  Non-replayable findings remain in `counts` and are excluded from the score's denominator.
+  A score of 1 can therefore coexist with `valid: false` when some findings were not replayable.
+
+Some result shapes use `score: 0` when no task measurement is available.
+For `VerificationReport`, use the presence of `taskScore` to identify a complete task measurement; `blendedScore` can describe a partial panel.
+An empty oracle set has certification metadata but returns `valid: false` and no executed oracle results.
+Read these completeness fields before using scores as task labels or release evidence.
+
+## Reading a score from a model judge
+
+A tied dimension score supplies no ordering between candidates.
+`llmJudge({ scoring })` controls how the dimension score is read:
+
+| `scoring` | Measurement | Requirement |
 |---|---|---|
-| `{ method: 'sampled' }` (default) | the grade the model emitted | nothing |
-| `{ method: 'expectation', whenUnavailable }` | the expected grade over the integer grades the model considered at the score token | `scale: 'ten'` and a provider that returns log probabilities |
-
-Expectation scoring asks the provider for `logprobs` with `top_logprobs`, finds the token that carried each dimension's grade, and averages the integer grades in that token's probability window, weighted by probability. Two answers that both sample `8` separate by how much mass sat on `7` versus `9`.
+| `{ method: 'sampled' }` (default) | The emitted grade | A valid grade response |
+| `{ method: 'expectation', whenUnavailable }` | A probability-weighted grade from returned token alternatives | `scale: 'ten'` and provider log probabilities |
 
-It needs one integer in one token, which is why `scale: 'ten'` is required: a `[0,1]` float is several tokens, and no single position carries its distribution. A grade that did not land in exactly one token — a two-token `10` — is refused rather than approximated.
+With `scale: 'ten'`, the model emits grades from 0 to 10; `llmJudge()` divides them by 10 before returning dimensions and composite.
+Expectation scoring finds each grade's token, keeps valid integer alternatives, and renormalizes their returned probabilities before averaging.
+Its distribution is limited to those returned alternatives.
+Additional precision alone does not establish better calibration or ranking accuracy.
 
-`whenUnavailable` decides what happens when the provider returns no log probabilities, or the grade spans tokens:
+Each emitted grade must occupy one integer token for expectation scoring.
+A split `10`, missing grade token, or unavailable log probabilities invokes `whenUnavailable`:
 
-- `'fail'` throws, and the campaign records a failed cell.
-- `'sampled'` reads the emitted grade instead.
+- `'fail'` throws; the campaign records a judge failure.
+- `'sampled'` uses the emitted grades for that judge result.
 
-`JudgeScore.scoringMethod` reports what actually produced the number, so a declared expectation run that fell back reads `'sampled'` and stays auditable. `JudgeScore.distribution` carries the probability mass per grade, and is present only for an expectation score. Panels are unchanged: `ensembleJudge` consumes the composite either way.
+`JudgeScore.scoringMethod` is present when `scoring` was explicitly configured and records the method used.
+An expectation request that falls back reports `'sampled'`.
+When `scoring` is omitted, sampled scoring is the default and this metadata field is absent.
+`JudgeScore.distribution` is present only for expectation scoring and contains the normalized probabilities over returned integer alternatives.
+`ensembleJudge()` consumes the resulting composite through its usual interface.
 
-Whether a given endpoint returns `logprobs.content` is a property of that provider and model, not of this package. `LlmCallResult.logprobs` is `null` when the provider returned none — never an inferred distribution. See `evidence/records/judge-logprob-wire-support.json` for the current verification state of that wire behavior.
+Provider and model support determines whether log probabilities are available.
+`LlmCallResult.logprobs` is `null` when none were returned.
+The [recorded wire check](../evidence/records/judge-logprob-wire-support.json) documents the endpoints and conditions that were inspected.
 
-## Consuming a certification
+## Interpreting certification limits
 
-Read `certification.strategy`, then weigh the member's documented failure mode — `VERIFICATION_STRATEGIES[strategy].failureMode` carries it at runtime.
-"Certified" is never one bit: a `judge` certificate is Goodhart-gameable, a `test` certificate covers only its suite, a `composite` certificate can hide which member carried the score.
-The assumptions list is the honest remainder; an empty list is the producer's explicit claim that nothing was left unverified, not a default.
+Read `VERIFICATION_STRATEGIES[strategy].failureMode` alongside the evidence and assumptions.
+A judge can reward misleading output; tests cover their suite; a proof can establish the wrong formal statement for the intended task.
+A composite certification requires inspection of its component results.
+An empty assumptions list is the producer's declaration, not independent verification that no assumptions remain.
 
-Related docs: [verification-strategies.md](./verification-strategies.md) (the family and the equivalence protocol), [trace-repair-grader.md](./trace-repair-grader.md), [trajectory-replay.md](./trajectory-replay.md).
+See [verification strategies](./verification-strategies.md), [repair grading](./trace-repair-grader.md), and [trajectory replay](./trajectory-replay.md) for the corresponding execution contracts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.179.0",
+  "version": "0.181.0",
   "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": {

package/dist/agent-profile-cell-0gSi5ffD.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-profile-cell-0gSi5ffD.js","names":["sortKeysDeep"],"sources":["../src/pre-registration.ts","../src/agent-profile-cell.ts"],"sourcesContent":["/**\n * Pre-registered hypotheses — declare what you're testing BEFORE the\n * run, check it AFTER. Prevents p-hacking, optional stopping, and the\n * \"we ran until it looked good\" failure mode.\n *\n * Manifest is a plain JSON-friendly object. Sign it with a content hash\n * + timestamp; the registered record becomes immutable. Post-run,\n * evaluate the manifest against observed results — the library refuses\n * to let you re-interpret a different metric as the declared one.\n *\n * A signed manifest is a portable record: it is written once and verified\n * later, possibly by a different release. `algo` names the digest scheme it\n * was signed under, and verification selects the encoder by that field, so a\n * manifest signed by an earlier release still verifies.\n */\n\nimport { createHash } from 'node:crypto'\nimport { canonicalString, hashCanonical } from './ledger-core/canonical'\n\nexport interface HypothesisManifest {\n  id: string\n  /** Human prose — goes into the audit trail. */\n  hypothesis: string\n  /** Metric the hypothesis claims to move. */\n  metric: string\n  /** 'increase' = candidate should score higher than baseline; 'decrease' = lower. */\n  direction: 'increase' | 'decrease'\n  /** Minimum effect size to count (same units as the metric). */\n  minEffect: number\n  /** Alpha threshold. */\n  alpha: number\n  /** Target statistical power at which sample size was pre-computed. */\n  power: number\n  /** Declared N per arm before running. */\n  preRegisteredN: number\n  /** ISO8601 timestamp the manifest was registered. */\n  registeredAt: string\n  /** Optional identifiers to tie into the trace corpus. */\n  baselineLabel?: string\n  candidateLabel?: string\n}\n\n/**\n * Identifier for the hashing scheme used to produce `contentHash`.\n *\n * Both schemes are sha256 hex over the manifest with `contentHash` and `algo`\n * stripped, and differ only in how that manifest is serialized:\n *\n * - `'sha256-rfc8785'` — RFC 8785 canonical JSON. What {@link signManifest}\n *   emits.\n * - `'sha256-content'` — key-sorted `JSON.stringify`. Read-only: manifests\n *   signed by an earlier release carry it, or carry no `algo` at all, and\n *   {@link verifyManifest} still verifies them.\n */\nexport type SignedManifestAlgo = 'sha256-content' | 'sha256-rfc8785'\n\nexport interface SignedManifest extends HypothesisManifest {\n  /** sha256 hex of canonicalized manifest (everything except contentHash and algo). */\n  contentHash: string\n  /**\n   * Algorithm string describing how `contentHash` was produced.\n   *\n   * Optional on the type so serialized manifests without it still parse,\n   * but ALWAYS populated by {@link signManifest}. Consumers that want to\n   * enforce a known algorithm should reject manifests where this field\n   * is missing or unrecognized.\n   */\n  algo?: SignedManifestAlgo\n}\n\nexport interface HypothesisResult {\n  manifest: SignedManifest\n  observedN: number\n  observedEffect: number\n  observedPValue: number\n  /** True iff the observed effect hits the pre-declared direction with\n   *  magnitude ≥ minEffect AND p < alpha. */\n  confirmed: boolean\n  /** Enumerated reasons the hypothesis was rejected (each a machine-tag). */\n  rejectionReasons: Array<\n    'wrong_direction' | 'effect_too_small' | 'not_significant' | 'undersampled'\n  >\n  notes?: string\n}\n\n/**\n * SHA-256 hex (full 64 chars) over the RFC 8785 canonical JSON encoding of\n * `obj` — the package's one identity scheme, shared with `ledger-core`.\n *\n * Values canonical JSON cannot represent faithfully — `undefined`, `NaN`,\n * class instances, cycles — are refused rather than coerced, because a\n * coercion maps two distinct records onto one digest.\n *\n * Named `hashJson` to disambiguate from `prompt-registry.ts`'s `hashContent`,\n * which takes a string input and returns a truncated 12-char prompt id.\n *\n * @example\n *   const hash = await hashJson({ id: '1', kind: 'spec' })\n *   // 'a3f1...' (64 hex chars)\n */\nexport async function hashJson<T>(obj: T): Promise<string> {\n  return hashCanonical(obj).slice('sha256:'.length)\n}\n\n/**\n * Key-sorted `JSON.stringify` digest. Private and read-only: it exists so a\n * manifest signed under `'sha256-content'` still verifies, and nothing that\n * WRITES a digest may call it.\n */\nfunction legacyContentDigest(value: unknown): string {\n  return createHash('sha256')\n    .update(JSON.stringify(sortKeysDeep(value)), 'utf8')\n    .digest('hex')\n}\n\nfunction sortKeysDeep(value: unknown): unknown {\n  if (value === null || typeof value !== 'object') return value\n  if (Array.isArray(value)) return value.map(sortKeysDeep)\n  const out: Record<string, unknown> = {}\n  for (const key of Object.keys(value as Record<string, unknown>).sort()) {\n    out[key] = sortKeysDeep((value as Record<string, unknown>)[key])\n  }\n  return out\n}\n\n/**\n * Digest of a manifest under its own declared scheme, with `contentHash` and\n * `algo` stripped. Synchronous, so a caller that must fail before consuming an\n * observation does not have to await. Throws on an `algo` this release does\n * not know — an unverifiable manifest must not read as a valid one.\n */\nexport function manifestContentDigest(manifest: SignedManifest): string {\n  const { contentHash: _contentHash, algo, ...rest } = manifest\n  void _contentHash\n  if (algo === undefined || algo === 'sha256-content') return legacyContentDigest(rest)\n  if (algo === 'sha256-rfc8785') {\n    return createHash('sha256').update(canonicalString(rest), 'utf8').digest('hex')\n  }\n  throw new Error(`pre-registration: unrecognized manifest hash algo '${String(algo)}'`)\n}\n\n/**\n * Sign a manifest with a SHA-256 content hash over its RFC 8785 canonical\n * JSON, with `contentHash` and `algo` stripped, and stamp the scheme in\n * `algo` so a later reader knows which encoder to verify with.\n */\nexport async function signManifest(m: HypothesisManifest): Promise<SignedManifest> {\n  const signed: SignedManifest = { ...m, contentHash: '', algo: 'sha256-rfc8785' }\n  return { ...signed, contentHash: manifestContentDigest(signed) }\n}\n\n/**\n * Verify that a signed manifest has not been tampered with, under the scheme\n * the manifest itself declares.\n */\nexport async function verifyManifest(m: SignedManifest): Promise<boolean> {\n  return manifestContentDigest(m) === m.contentHash\n}\n\n/**\n * Evaluate a pre-registered hypothesis against observed results.\n * Mechanical — no re-interpretation permitted.\n */\nexport async function evaluateHypothesis(\n  manifest: SignedManifest,\n  observed: { n: number; effect: number; pValue: number },\n): Promise<HypothesisResult> {\n  if (!(await verifyManifest(manifest))) {\n    throw new Error('evaluateHypothesis: manifest content hash mismatch (tampered)')\n  }\n  const reasons: HypothesisResult['rejectionReasons'] = []\n  const directionOk = manifest.direction === 'increase' ? observed.effect > 0 : observed.effect < 0\n  if (!directionOk) reasons.push('wrong_direction')\n  if (Math.abs(observed.effect) < manifest.minEffect) reasons.push('effect_too_small')\n  if (observed.pValue >= manifest.alpha) reasons.push('not_significant')\n  if (observed.n < manifest.preRegisteredN) reasons.push('undersampled')\n  return {\n    manifest,\n    observedN: observed.n,\n    observedEffect: observed.effect,\n    observedPValue: observed.pValue,\n    confirmed: reasons.length === 0,\n    rejectionReasons: reasons,\n  }\n}\n","import { createHash } from 'node:crypto'\nimport type { AgentProfile } from '@tangle-network/agent-interface'\nimport { ValidationError } from './errors'\nimport { hashJson } from './pre-registration'\n\nexport type AgentProfileCellSchemaVersion = 'agent-profile-cell/v1'\n\nexport type AgentProfileJsonObject = { [key: string]: AgentProfileJson }\n\nexport type AgentProfileJson =\n  | string\n  | number\n  | boolean\n  | null\n  | AgentProfileJson[]\n  | AgentProfileJsonObject\n\nexport type AgentProfileDimensionValue = string | number | boolean | null\n\nexport interface AgentProfileSource {\n  /** Runtime/profile contract being fingerprinted, e.g. `agent-interface-profile`. */\n  kind: string\n  /** sha256 over the canonical source profile object. */\n  hash: string\n}\n\nexport interface AgentProfileSourceInput {\n  kind: string\n  /** Precomputed sha256 for callers that already sign their profile artifact. */\n  hash?: string\n  /** Full canonical runtime profile; hashed and then discarded from the cell. */\n  profile?: AgentProfileJson\n}\n\nexport interface AgentProfileHarness {\n  id: string\n  version?: string\n  hash?: string\n}\n\nexport interface AgentProfileCellInput {\n  profileId: string\n  sourceProfile: AgentProfileSourceInput\n  harness?: AgentProfileHarness\n  model?: string\n  promptHash?: string\n  dimensions?: Record<string, AgentProfileDimensionValue>\n}\n\nexport interface AgentProfileCell {\n  schemaVersion: AgentProfileCellSchemaVersion\n  cellId: string\n  profileId: string\n  sourceProfile: AgentProfileSource\n  harness?: AgentProfileHarness\n  model?: string\n  promptHash?: string\n  dimensions?: Record<string, AgentProfileDimensionValue>\n}\n\nexport class AgentProfileCellValidationError extends ValidationError {\n  readonly path: string\n  constructor(message: string, path = '') {\n    super(path ? `${message} (at ${path})` : message)\n    this.path = path\n  }\n}\n\nconst SHA256_HEX = /^[0-9a-f]{64}$/\n/**\n * A cell id names the digest scheme that produced it. `sha256-rfc8785` is what\n * {@link buildAgentProfileCell} mints; the bare `sha256` form is read-only,\n * carried by cells built under an earlier release, and still verifies.\n */\nconst CELL_ID = /^agent-profile-cell:sha256(?:-rfc8785)?:[0-9a-f]{64}$/\nconst CELL_ID_PREFIX = 'agent-profile-cell:sha256-rfc8785:'\nconst LEGACY_CELL_ID_PREFIX = 'agent-profile-cell:sha256:'\n\nexport async function buildAgentProfileCell(\n  input: AgentProfileCellInput,\n): Promise<AgentProfileCell> {\n  const material = await normalizeAgentProfileCellInput(input)\n  const cellId = `${CELL_ID_PREFIX}${await hashJson(material)}`\n  return { ...material, cellId }\n}\n\nexport function agentProfileCellHashMaterial(\n  cell: AgentProfileCell,\n): Omit<AgentProfileCell, 'cellId'> {\n  const { cellId: _cellId, ...material } = cell\n  void _cellId\n  return normalizeAgentProfileCell(material)\n}\n\n/**\n * Verify an `AgentProfileCell`'s `cellId` matches the sha256 of its hash-material\n * fields, confirming the record has not been tampered with. The id names its own\n * digest scheme, so a cell minted by an earlier release verifies under that scheme.\n */\nexport async function verifyAgentProfileCell(cell: AgentProfileCell): Promise<boolean> {\n  validateAgentProfileCell(cell)\n  const material = agentProfileCellHashMaterial(cell)\n  if (cell.cellId.startsWith(CELL_ID_PREFIX)) {\n    return cell.cellId === `${CELL_ID_PREFIX}${await hashJson(material)}`\n  }\n  return cell.cellId === `${LEGACY_CELL_ID_PREFIX}${legacyCellDigest(material)}`\n}\n\n/**\n * Key-sorted `JSON.stringify` digest. Private and read-only: it verifies a cell\n * id minted before the RFC 8785 scheme, and no path that MINTS an id calls it.\n */\nfunction legacyCellDigest(value: unknown): string {\n  return createHash('sha256')\n    .update(JSON.stringify(sortKeysDeep(value)), 'utf8')\n    .digest('hex')\n}\n\nfunction sortKeysDeep(value: unknown): unknown {\n  if (value === null || typeof value !== 'object') return value\n  if (Array.isArray(value)) return value.map(sortKeysDeep)\n  const out: Record<string, unknown> = {}\n  for (const key of Object.keys(value as Record<string, unknown>).sort()) {\n    out[key] = sortKeysDeep((value as Record<string, unknown>)[key])\n  }\n  return out\n}\n\nexport function validateAgentProfileCell(input: unknown): AgentProfileCell {\n  if (input === null || typeof input !== 'object') {\n    throw new AgentProfileCellValidationError('expected object')\n  }\n  const obj = input as Record<string, unknown>\n  expectLiteral(obj.schemaVersion, 'agent-profile-cell/v1', 'schemaVersion')\n  if (typeof obj.cellId !== 'string' || !CELL_ID.test(obj.cellId)) {\n    throw new AgentProfileCellValidationError(\n      'cellId must match agent-profile-cell:sha256:<64 lowercase hex chars>',\n      'cellId',\n    )\n  }\n  expectString(obj.profileId, 'profileId')\n  validateSource(obj.sourceProfile, 'sourceProfile')\n  if (obj.harness !== undefined) validateHarness(obj.harness, 'harness')\n  if (obj.model !== undefined) expectString(obj.model, 'model')\n  if (obj.promptHash !== undefined) expectString(obj.promptHash, 'promptHash')\n  if (obj.dimensions !== undefined) validateDimensions(obj.dimensions, 'dimensions')\n  return input as AgentProfileCell\n}\n\nexport function requireAgentProfileCell(record: {\n  runId: string\n  agentProfile?: AgentProfileCell\n}): AgentProfileCell {\n  if (!record.agentProfile) {\n    throw new AgentProfileCellValidationError(\n      `run \"${record.runId}\" is missing agentProfile; profile-cell grouping requires explicit profile identity`,\n      'agentProfile',\n    )\n  }\n  return validateAgentProfileCell(record.agentProfile)\n}\n\nexport function agentProfileCellKey(record: {\n  runId: string\n  agentProfile?: AgentProfileCell\n}): string {\n  return requireAgentProfileCell(record).cellId\n}\n\nexport async function assertRunAgentProfileCell(record: {\n  runId: string\n  model: string\n  promptHash: string\n  agentProfile?: AgentProfileCell\n}): Promise<AgentProfileCell> {\n  const profile = requireAgentProfileCell(record)\n  if (!(await verifyAgentProfileCell(profile))) {\n    throw new AgentProfileCellValidationError(\n      `run \"${record.runId}\" has an agentProfile.cellId that does not match its content`,\n      'agentProfile.cellId',\n    )\n  }\n  if (profile.model !== undefined && profile.model !== record.model) {\n    throw new AgentProfileCellValidationError(\n      `run \"${record.runId}\" agentProfile.model \"${profile.model}\" does not match model \"${record.model}\"`,\n      'agentProfile.model',\n    )\n  }\n  if (profile.promptHash !== undefined && profile.promptHash !== record.promptHash) {\n    throw new AgentProfileCellValidationError(\n      `run \"${record.runId}\" agentProfile.promptHash \"${profile.promptHash}\" does not match promptHash \"${record.promptHash}\"`,\n      'agentProfile.promptHash',\n    )\n  }\n  return profile\n}\n\nexport function groupRunsByAgentProfileCell<\n  T extends { runId: string; agentProfile?: AgentProfileCell },\n>(records: readonly T[]): Map<string, T[]> {\n  const groups = new Map<string, T[]>()\n  for (const record of records) {\n    const key = agentProfileCellKey(record)\n    const bucket = groups.get(key)\n    if (bucket) bucket.push(record)\n    else groups.set(key, [record])\n  }\n  return groups\n}\n\nasync function normalizeAgentProfileCellInput(\n  input: AgentProfileCellInput,\n): Promise<Omit<AgentProfileCell, 'cellId'>> {\n  return normalizeAgentProfileCell({\n    schemaVersion: 'agent-profile-cell/v1',\n    profileId: input.profileId,\n    sourceProfile: await normalizeSourceInput(input.sourceProfile),\n    harness: input.harness,\n    model: input.model,\n    promptHash: input.promptHash,\n    dimensions: input.dimensions,\n  })\n}\n\nfunction normalizeAgentProfileCell(\n  input: Omit<AgentProfileCell, 'cellId'>,\n): Omit<AgentProfileCell, 'cellId'> {\n  return compactObject({\n    schemaVersion: 'agent-profile-cell/v1' as const,\n    profileId: requireNonEmpty(input.profileId, 'profileId'),\n    sourceProfile: normalizeSource(input.sourceProfile),\n    harness: input.harness ? normalizeHarness(input.harness, 'harness') : undefined,\n    model: optionalNonEmpty(input.model, 'model'),\n    promptHash: optionalNonEmpty(input.promptHash, 'promptHash'),\n    dimensions: input.dimensions\n      ? nonEmptyRecord(normalizeDimensions(input.dimensions))\n      : undefined,\n  })\n}\n\nasync function normalizeSourceInput(input: AgentProfileSourceInput): Promise<AgentProfileSource> {\n  const kind = requireNonEmpty(input.kind, 'sourceProfile.kind')\n  if (input.hash !== undefined && input.profile !== undefined) {\n    throw new AgentProfileCellValidationError(\n      'sourceProfile must provide either hash or profile, not both',\n      'sourceProfile',\n    )\n  }\n  if (input.hash !== undefined) {\n    return { kind, hash: requireSha256Hex(input.hash, 'sourceProfile.hash') }\n  }\n  if (input.profile === undefined) {\n    throw new AgentProfileCellValidationError(\n      'sourceProfile must provide hash or profile',\n      'sourceProfile',\n    )\n  }\n  assertJson(input.profile, 'sourceProfile.profile')\n  return { kind, hash: await hashJson(input.profile) }\n}\n\nfunction normalizeSource(input: AgentProfileSource): AgentProfileSource {\n  return {\n    kind: requireNonEmpty(input.kind, 'sourceProfile.kind'),\n    hash: requireSha256Hex(input.hash, 'sourceProfile.hash'),\n  }\n}\n\nfunction normalizeHarness(input: AgentProfileHarness, path: string): AgentProfileHarness {\n  return compactObject({\n    id: requireNonEmpty(input.id, `${path}.id`),\n    version: optionalNonEmpty(input.version, `${path}.version`),\n    hash: optionalNonEmpty(input.hash, `${path}.hash`),\n  })\n}\n\nfunction normalizeDimensions(\n  input: Record<string, AgentProfileDimensionValue>,\n): Record<string, AgentProfileDimensionValue> {\n  const out: Record<string, AgentProfileDimensionValue> = {}\n  for (const key of Object.keys(input).sort()) {\n    const value = input[key]\n    requireNonEmpty(key, 'dimensions.<key>')\n    if (\n      value !== null &&\n      typeof value !== 'string' &&\n      typeof value !== 'number' &&\n      typeof value !== 'boolean'\n    ) {\n      throw new AgentProfileCellValidationError(\n        'expected primitive dimension value',\n        `dimensions.${key}`,\n      )\n    }\n    if (typeof value === 'number' && !Number.isFinite(value)) {\n      throw new AgentProfileCellValidationError('expected finite number', `dimensions.${key}`)\n    }\n    out[key] = value\n  }\n  return out\n}\n\nfunction compactObject<T extends Record<string, unknown>>(input: T): T {\n  const out: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(input)) {\n    if (value !== undefined) out[key] = value\n  }\n  return out as T\n}\n\nfunction nonEmptyRecord<T extends Record<string, unknown>>(input: T): T | undefined {\n  return Object.keys(input).length > 0 ? input : undefined\n}\n\nfunction validateSource(value: unknown, path: string): void {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new AgentProfileCellValidationError('expected object', path)\n  }\n  const rec = value as Record<string, unknown>\n  expectString(rec.kind, `${path}.kind`)\n  requireSha256Hex(rec.hash, `${path}.hash`)\n}\n\nfunction validateHarness(value: unknown, path: string): void {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new AgentProfileCellValidationError('expected object', path)\n  }\n  const rec = value as Record<string, unknown>\n  expectString(rec.id, `${path}.id`)\n  if (rec.version !== undefined) expectString(rec.version, `${path}.version`)\n  if (rec.hash !== undefined) expectString(rec.hash, `${path}.hash`)\n}\n\nfunction validateDimensions(value: unknown, path: string): void {\n  if (value === null || typeof value !== 'object' || Array.isArray(value)) {\n    throw new AgentProfileCellValidationError('expected object', path)\n  }\n  normalizeDimensions(value as Record<string, AgentProfileDimensionValue>)\n}\n\nfunction assertJson(value: AgentProfileJson, path: string): void {\n  if (value === null) return\n  const type = typeof value\n  if (type === 'string' || type === 'boolean') return\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new AgentProfileCellValidationError('expected finite number', path)\n    }\n    return\n  }\n  if (Array.isArray(value)) {\n    value.forEach((item, index) => {\n      assertJson(item, `${path}[${index}]`)\n    })\n    return\n  }\n  if (type === 'object') {\n    for (const [key, nested] of Object.entries(value)) {\n      requireNonEmpty(key, `${path}.<key>`)\n      assertJson(nested, `${path}.${key}`)\n    }\n    return\n  }\n  throw new AgentProfileCellValidationError('expected JSON-compatible value', path)\n}\n\nfunction expectLiteral(value: unknown, expected: string, path: string): void {\n  if (value !== expected) {\n    throw new AgentProfileCellValidationError(`expected ${expected}`, path)\n  }\n}\n\nfunction expectString(value: unknown, path: string): void {\n  if (typeof value !== 'string' || value.length === 0) {\n    throw new AgentProfileCellValidationError('expected non-empty string', path)\n  }\n}\n\nfunction requireNonEmpty(value: string, path: string): string {\n  if (typeof value !== 'string' || value.length === 0) {\n    throw new AgentProfileCellValidationError('expected non-empty string', path)\n  }\n  return value\n}\n\nfunction optionalNonEmpty(value: string | undefined, path: string): string | undefined {\n  if (value === undefined) return undefined\n  return requireNonEmpty(value, path)\n}\n\nfunction requireSha256Hex(value: unknown, path: string): string {\n  if (typeof value !== 'string' || !SHA256_HEX.test(value)) {\n    throw new AgentProfileCellValidationError('expected 64 lowercase sha256 hex chars', path)\n  }\n  return value\n}\n\n// ── Consumer helpers ─────────────────────────────────────────────────\n//\n// Boilerplate every product consuming `buildAgentProfileCell` used to duplicate:\n//\n//   1. A `JSON.parse(JSON.stringify(value))` helper that canonicalizes an\n//      arbitrary `@tangle-network/agent-interface` `AgentProfile` into the recursive\n//      `AgentProfileJson` shape, with a fail-loud error when the profile\n//      is not JSON-serializable.\n//\n//   2. The magic string `'agent-interface-profile'` for `sourceProfile.kind`.\n//\n// Both belong here so the cross-product cell join (same canonical profile\n// hashes to the same `sourceProfile.hash` across products) is enforced by\n// the type system, not by every consumer remembering to do it right.\n// See blueprint-agent issue tangle-network/agent-eval#82.\n\n/** Canonical `sourceProfile.kind` values. Two products fingerprinting the\n *  same canonical profile MUST use the same kind for their cells to share\n *  `sourceProfile.hash`. Extend rather than create new strings — adding a\n *  new kind is a deliberate cross-product schema change. */\nexport const AGENT_PROFILE_KINDS = {\n  /** A profile declared via `defineAgentProfile(...)` from\n   *  `@tangle-network/agent-interface`. The default kind for router-backed\n   *  and sandbox-backed products. */\n  AGENT_INTERFACE_PROFILE: 'agent-interface-profile',\n} as const\n\nexport type AgentProfileKind = (typeof AGENT_PROFILE_KINDS)[keyof typeof AGENT_PROFILE_KINDS]\n\n/** Canonicalize an arbitrary value into `AgentProfileJson` by JSON\n *  round-trip. Throws when the value contains anything not representable\n *  as JSON (functions, BigInt, cycles) — non-portable profiles fail loud\n *  rather than silently dropping fields. */\nexport function toAgentProfileJson(value: unknown): AgentProfileJson {\n  let serialized: string | undefined\n  try {\n    serialized = JSON.stringify(value)\n  } catch (err) {\n    throw new AgentProfileCellValidationError(\n      `agent profile must be JSON-serializable: ${err instanceof Error ? err.message : String(err)}`,\n      'sourceProfile.profile',\n    )\n  }\n  if (serialized === undefined) {\n    throw new AgentProfileCellValidationError(\n      'agent profile must be JSON-serializable (got undefined after JSON.stringify)',\n      'sourceProfile.profile',\n    )\n  }\n  return JSON.parse(serialized) as AgentProfileJson\n}\n\n/** Canonical AgentProfile shape required when deriving a stable cell id. */\nexport type AgentInterfaceProfileLike = AgentProfile & { name: string; version: string }\n\n/** Higher-level helper that hard-codes the canonical\n *  `agent-interface-profile` kind plus the JSON canonicalization. Equivalent\n *  to calling `buildAgentProfileCell` with `profileId = \\`${name}@${version}\\``\n *  and `sourceProfile = { kind: AGENT_INTERFACE_PROFILE, profile: <round-tripped> }`.\n *\n *  Use this from any product consuming an agent-interface `AgentProfile`; the\n *  manual `buildAgentProfileCell` call is reserved for advanced cases\n *  (custom kinds, pre-computed source hashes, alternate profileId\n *  conventions). */\nexport async function buildAgentInterfaceProfileCell(\n  profile: AgentInterfaceProfileLike,\n  input: Omit<AgentProfileCellInput, 'profileId' | 'sourceProfile'>,\n): Promise<AgentProfileCell> {\n  if (!profile || typeof profile !== 'object') {\n    throw new AgentProfileCellValidationError('AgentProfile must be an object', 'profile')\n  }\n  if (typeof profile.name !== 'string' || profile.name.length === 0) {\n    throw new AgentProfileCellValidationError(\n      'AgentProfile must have a non-empty `name`',\n      'profile.name',\n    )\n  }\n  if (typeof profile.version !== 'string' || profile.version.length === 0) {\n    throw new AgentProfileCellValidationError(\n      'AgentProfile must have a non-empty `version`',\n      'profile.version',\n    )\n  }\n  return buildAgentProfileCell({\n    ...input,\n    profileId: `${profile.name}@${profile.version}`,\n    sourceProfile: {\n      kind: AGENT_PROFILE_KINDS.AGENT_INTERFACE_PROFILE,\n      profile: toAgentProfileJson(profile),\n    },\n  })\n}\n"],"mappings":"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"}

package/dist/agent-profile-cell-CTOZJUuE.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-profile-cell-CTOZJUuE.d.ts","names":[],"sources":["../src/agent-profile-cell.ts"],"mappings":";;;KAKY;KAEA;GAA4B,cAAc;;KAE1C,sDAKR,qBACA;KAEQ;UAEK;;EAEf;;EAEA;;UAGe;EACf;;EAEA;;EAEA,UAAU;;UAGK;EACf;EACA;EACA;;UAGe;EACf;EACA,eAAe;EACf,UAAU;EACV;EACA;EACA,aAAa,eAAe;;UAGb;EACf,eAAe;EACf;EACA;EACA,eAAe;EACf,UAAU;EACV;EACA;EACA,aAAa,eAAe;;cAGjB,wCAAwC;WAC1C;EACT,YAAY,iBAAiB;;iBAgBT,sBACpB,OAAO,wBACN,QAAQ;iBAMK,6BACd,MAAM,mBACL,KAAK;;;;;;iBAWc,uBAAuB,MAAM,mBAAmB;iBA6BtD,yBAAyB,iBAAiB;iBAqB1C,wBAAwB;EACtC;EACA,eAAe;IACb;iBAUY,oBAAoB;EAClC;EACA,eAAe;;iBAKK,0BAA0B;EAC9C;EACA;EACA;EACA,eAAe;IACb,QAAQ;iBAuBI,4BACd;EAAY;EAAe,eAAe;GAC1C,kBAAkB,MAAM,YAAY;;;;;cA0NzB;;;;WAIX;;KAGU,2BAA2B,kCAAkC;;;;;iBAMzD,mBAAmB,iBAAiB;;KAoBxC,4BAA4B;EAAiB;EAAc;;;;;;;;;;;iBAWjD,+BACpB,SAAS,2BACT,OAAO,KAAK,wDACX,QAAQ"}