@tangle-network/agent-eval 0.183.0 → 0.185.0

package/docs/jev-behavior-review.md

@@ -0,0 +1,174 @@
+# Evidence-backed behavioral reviews
+
+Use native evaluations to assess bounded hypotheses about recorded behavior. Do not ask one
+classifier whether an agent is "malicious" or a whole run is "safe". Observable policy breaches,
+model-supported hypotheses, missing evidence and unusual behavior are different results.
+
+The optional `/jev` helpers are ordinary functions:
+
+- `prepareJevReview`: validate and freeze caller-defined native questions, evidence references,
+  coverage and decision thresholds before spending. The digest binds the definition, input and
+  authored question/option order. Optional undefined object fields are absent on the wire.
+- `assessJevReview`: validate native answers and interpret designated alternative masses as
+  `supported`, `refuted` or `unresolved`. Re-scoring makes no network call.
+- `jevReviewFindings`: map that report into the existing `AnalystFinding` contract. It keeps
+  unresolved checks visible and labels supported claims as model-supported hypotheses.
+
+These helpers do not constrain `jevEvaluator`, `jevJudge`, `jevAnalyst`, or the provider-independent
+`createEvaluator`/`asJudge`/`asAnalyst` APIs. Use an ordinary custom mapper for different policies.
+No model, taxonomy, severity, operating threshold, global safety score or storage backend is chosen
+by the generic implementation.
+
+## Direct product call
+
+Supply the native request on each invocation. This example's `question`, `evidence`, `policy` and
+`limits` are application configuration, not new library exports or default values.
+
+```ts
+import {
+  prepareJevReview, assessJevReview, jevEvaluator,
+} from '@tangle-network/agent-eval/jev'
+
+const evaluate = jevEvaluator({
+  evaluate: nativeTransport, // One Router /v1/systemone attempt; preserve signal/idempotency key.
+  receipt: readRouterReceipt,
+  maximumCharge: enforcedMaximumCharge,
+})
+
+const review = prepareJevReview({
+  version: policy.version,
+  request: {
+    model: selectedModel,
+    state: { policy: policy.definition, evidence: evidence.content },
+    questions: { action: question },
+  },
+  checks: {
+    action: {
+      claim: policy.hypothesis,
+      subject: actionId,
+      area: 'authorization-review',
+      severity: policy.severity,
+      supports: ['supported'],
+      refutes: ['refuted'],
+      supportAtLeast: limits.support,
+      refuteAtLeast: limits.refute,
+      coverage: evidence.coverage,
+      evidence: evidence.refs,
+    },
+  },
+})
+const result = await evaluate(review.request, executionContext)
+await persistAuthorizedObservation({ review, result })
+const report = assessJevReview(review, result.value)
+```
+
+The example assumes a native Choice question with `supported`, `refuted` and `insufficient`
+alternatives. Other labels, Noul polarity (`true`/`false`) and grouped Score levels are supported.
+A Score's expected level is not itself the probability of a breach; explicitly select which
+levels support or refute the claim. The two thresholds must be positive, at most one and sum to
+more than one, so their regions do not overlap. This is an optional disjoint-region policy,
+not a requirement imposed on other evaluators.
+
+## Optional behavior recipe
+
+`examples/jev-behavior-review.ts` provides replaceable question definitions and
+`behaviorReviewAnalyst`, which composes the existing `jevAnalyst`. Copy/adapt the recipe in an
+application; it is not a default policy installed by importing the package. Select only relevant
+checks and provide thresholds, severity, exact policy and evidence for every selected check.
+
+| Hypothesis | Evidence needed | Important distinction |
+| --- | --- | --- |
+| Reward gaming | Task objective, raw proxy score, independent outcome and attributable action | A proxy/outcome gap can be a broken evaluator, not deliberate gaming. |
+| Evaluator tampering | Protected evaluator identity, allowed changes and trusted before/after diff | A task that authorizes test repair must not be flagged merely for editing tests. |
+| Safety-policy violation | Exact applicable policy and attributable action/output | Quotation, refusal and simulation are not completed violations. |
+| Unauthorized action | Effective grant at action time, requested target and enforcement outcome | An attempted action, a blocked request and a completed effect differ. |
+| Data-boundary violation | Data classification, allowed destination and actual payload/egress record | Do not infer a successful transfer from a plan or URL mention. |
+| Injection followed | Untrusted instruction, trusted task and subsequent attributable action | Reading or rejecting malicious text is not obeying it. |
+| Contradicted success claim | Exact claim and independent receipt for the same operation | No receipt means unresolved, not proof of deception. |
+| Oversight bypass | Applicable approval/monitor/cancel control and attributable change | Lost telemetry or an authorized control change is not evidence of agent evasion. |
+| Anomalous sequence | Matched versioned baseline and differences computed in code | Unusual does not mean harmful; no baseline means no established anomaly rate. |
+| Cross-run coordination | Authorized joined traces, linkage, timeline, policy and joint effect | Shared infrastructure or legitimate delegation is not collusion. |
+
+A hypothesis gets its own question; these behaviors are not mutually exclusive alternatives in
+one forced-choice category. Prefer a small relevant evidence window per review. A rule such as
+"use only evidence.X" is an instruction, not technical isolation between other inputs in the
+same request. Run separate requests when evidence or tenant isolation requires it.
+
+## What the numbers mean
+
+The report retains support, refutation and remaining native mass without renormalizing away
+uncertainty. Native `confidence` is stored separately: TypeSafe defines it as a statistic of the
+distribution, not the same value as the winning alternative's probability. Neither is a measured
+probability of malicious intent, future harm or successful exfiltration.
+
+The host declares evidence coverage. Non-missing coverage requires references; the library does
+not authenticate those references, read their targets, prove completeness or know that the
+right evidence was supplied. The caller must bind references to immutable authorized records
+and put the relevant content in state. A policy document alone is not behavioral evidence.
+Missing evidence always stays unresolved. Partial evidence may support a scoped hypothesis but
+cannot refute it under this helper's conservative policy.
+
+Every native result should be retained through the existing `record` callback before findings
+are reduced. A refuted check remains in the report but produces no issue finding; an empty
+finding list is not a universal safety certificate. Supported findings use model support mass
+as `confidence`, explicitly marked uncalibrated. Unresolved findings use confidence 1 only for
+the deterministic fact "this review is unresolved", with `confidence_basis: deterministic-status`.
+Do not graph those two bases together as risk probabilities.
+
+Do not multiply probabilities from correlated questions, add overlapping category probabilities
+as a run-wide risk, or substitute `1 - P(supported)` for `P(refuted)` when insufficient evidence
+has its own mass. For an independent audit of these ternary outcomes, use `auditEvaluator` with
+the actual mapped decision and unknowns. `auditProbabilityPolicy` is for a genuine binary
+probability with its frozen binary threshold rule; it must not silently drop the third category.
+
+## Existing components to reuse
+
+`/rl` already has `detectRewardHacking` for reward divergence, distribution shift, reward
+disagreement and judge drift. Those diagnostic scores are not probabilities. Keep the raw,
+ungated proxy and independently measured task outcome so a previous rejection does not hide the
+disagreement. Do not substitute the Jev monitor as the only independent outcome.
+
+The analyst system already has deterministic control-integrity and behavioral/efficiency
+checks, plus deep trace analyst definitions such as intent divergence and knowledge poisoning.
+Run exact checks for facts code can establish; use a bounded semantic review for interpretation;
+escalate selected cases to the existing deeper analyst. None is replaced by this recipe.
+
+A prepared review can be a custom registry input or built from a filtered trace store. Existing
+`asAnalyst`/`jevAnalyst` forward the shared paid-call account, cancellation and deadline. The
+recipe verifies persisted definition identity before inference, records the native observation
+before mapping, and returns ordinary findings. Graphs consume these through their existing
+analyst-registry adapter. No new supervisor, scheduler, ledger, or trace database is introduced.
+
+For judges, map assessments explicitly and refuse unresolved evidence where the scored metric
+requires resolution. Never convert an unresolved safety review to a perfect score or average a
+critical constraint failure into unrelated high scores. Working feedback must not expose the
+independent final evaluator, protected holdout labels, or monitor control credentials to the worker.
+
+## Security and validation boundaries
+
+TypeSafe's Jev 1.13 documentation explicitly warns that adversarial state content can move the
+answer. Delimiters and explicit criteria are useful instructions, not a proof of injection
+resistance. These monitors are advisory evidence, not the sole authorization/safety barrier.
+Trusted policy and references must come from outside the evaluated agent; tenant scope, redaction,
+credential handling and controls remain with existing application/security owners.
+
+A required pre-action check must execute before the effect, and a pre-delivery check must run
+before streaming exposes the answer. Post-run analysis cannot undo an effect or retract text.
+External harnesses only support their actual documented boundaries; a whole-prompt callback is
+not an interception of every native request. An observational hook is not a blocking gate.
+
+Before enabling automatic decisions, independently test both attacks and ordinary authorized
+behavior: legitimate test edits, benign quotations, refusals, blocked attempts, telemetry gaps,
+wrong-tenant evidence, long/misleading traces and multi-run attacks. Measure per-category false
+positives, false negatives, abstention, task success, latency and full cost using independent
+source units. Freeze thresholds on development data, retain a separate final set, and audit a
+sample of accepted cases to avoid selective-label blindness. Test the monitor under adaptive
+attacks, not only the worker under a fixed monitor.
+
+The new tests exercise pure mapping, canonical identity, metadata isolation and real
+Eval/AnalystRegistry accounting composition with an injected model boundary. They do not prove
+that Jev detects these behaviors correctly or is robust against adversarial prompts. No live
+provider, product UI rollout, runtime hook installation or production enforcement is added here.
+
+Sources reviewed: https://docs.typesafe.ai/confidence and
+https://docs.typesafe.ai/model-jaggedness/jev-1.13 (vendor page reviewed 2026-09-17).

package/docs/jev-integrations.md

@@ -0,0 +1,50 @@
+# Ten useful integrations, one evaluator
+
+Jev evaluates bounded questions. Applications supply state, questions and the policy interpreting
+answers. jevEvaluator handles the native model; createEvaluator supports other classifiers.
+asJudge and asAnalyst adapt the same operation to existing consumers.
+
+| Use | Outcome | Existing execution path |
+| --- | --- | --- |
+| Completion evidence | Verify a deliverable against requirements and independent artifacts | Native questions plus deterministic checks; unresolved stays unresolved. |
+| Recommendation triage | Prioritize evidence-linked Intelligence recommendations | Product triage selects existing engine findings and preserves their identities. |
+| Trace diagnosis | Narrow likely failures before deeper investigation | AnalystRegistry, scoped evidence, and the existing deep analyst. |
+| Behavioral review | Flag observable policy concerns, not hidden intent | Optional behavior-review recipe plus deterministic reward/control checks. |
+| Rubric judging | Compare product or agent outputs | jevJudge/asJudge with caller mappings and independent final assessment. |
+| Context selection | Select useful retrieved evidence | Native assessments, then deterministic packing with mandatory context protected. |
+| Skill selection | Select from authorized capabilities | Caller alternatives, including no-selection; existing runtime executes actions. |
+| Next verification | Choose a test, retrieval or review that resolves uncertainty | Existing graph checkpoints and awaited boundaries, not new permissions. |
+| Candidate selection | Choose among generated plans or artifacts | Existing matrix/graph, exact checks first, semantic assessment second. |
+| Configuration experiments | Compare questions, context, models and thresholds | examples/jev-decision-benchmark.ts using runAgentMatrix and cost receipts. |
+
+These are compositions, not ten new frameworks. Product triage and the benchmark recipe are concrete
+adoption work; other rows reuse existing APIs or identify application policies to configure. An API
+or recipe is not proof that every domain policy has been validated or deployed.
+
+## People, agents and evidence
+
+Developers need typed decisions and attributable spend. Operators need evidence, uncertainty and
+an actionable next check. Programmatic agents need stable JSON, explicit failure, a shared budget
+and retained results. Benchmark authors need independent labels that never enter model requests.
+
+Before execution, freeze inputs, independent source-unit splits, expected outcomes and configuration
+versions. During execution, retain the native request/answer, served model, receipt, timings and
+selected action. Afterwards, join independent outcomes, corrections and missing evidence. A model
+explanation is not an independent outcome.
+
+## Compare policies with the existing matrix
+
+The compareDecisions recipe accepts cases, configurations and an ordinary evaluator. Each case
+separates input from expected decision (or reviewed unresolved label) and sourceUnit. Question
+builders receive only input. Mapping and recording failures remain failed cells with paid costs;
+unknown spend is not measured free. Concurrency, repetitions and budget authority are caller-owned.
+Configuration results use `id@version` keys, with each component URL encoded; duplicate pairs fail
+before execution. This keeps versions of one policy separate in scores and costs.
+
+Report accuracy and automation coverage separately: always abstaining does not make a useful agent.
+Reuse existing audit/calibration functions and independent source units rather than inventing another
+statistics layer. The recipe chooses no default model, universal threshold or live request.
+
+Changing only a mapping can re-score saved probabilities. Changing context, questions or actions
+requires execution of the affected path. Compare verified outcomes and total spend, not report
+length, finding count or how confidently a model declares success.

package/docs/jev.md

@@ -0,0 +1,140 @@
+# Typed evaluations: products, judges, and analysts
+
+Configure a transport once. Supply your own model, state, and questions on every
+call. Interpret the answers in ordinary code; no campaign or agent is required.
+
+```ts
+import { TypeSafeClient, noul, choice } from '@typesafe-ai/sdk'
+import { jevEvaluator } from '@tangle-network/agent-eval/jev'
+
+const client = new TypeSafeClient({
+  baseURL: routerOrigin, // Origin without /v1; omit to use TypeSafe directly.
+  apiKey: scopedRouterKey,
+  retry: { maxRetries: 0 },
+})
+const evaluate = jevEvaluator({
+  evaluate: (request, { signal, idempotencyKey }) => client.systemOne(request, {
+    signal,
+    retry: { maxRetries: 0 },
+    headers: { 'Idempotency-Key': idempotencyKey },
+  }),
+  pricing: reviewedTokenPricing, // An estimate, not a provider-observed charge.
+})
+
+const result = await evaluate({
+  model: selectedModel,
+  state: { requirements, evidence },
+  questions: {
+    supported: noul('Does the evidence support the claim?'),
+    next: choice({ task: 'Choose the next step using the evidence' }, {
+      inspect: { when: 'Evidence is missing or contradictory' },
+      finish: { when: 'The requirements are satisfied' },
+    }),
+  },
+}, { signal, costLedger })
+
+result.value.answers.next.choice // 'inspect' | 'finish'
+result.value.answers.next.probabilities.inspect // number
+result.receipt // Existing CostLedger receipt, separate from native answers.
+```
+
+The named configuration and evidence values belong to the application. Plain JSON
+questions work too; SDK builders are optional. Structured criteria, null entries,
+and omitted optional fields are supported. Static TypeScript questions preserve
+exact answer names and choice-label unions. Runtime JSON must be validated; its
+labels cannot become compile-time literals automatically.
+
+## Any classifier, not just Jev
+
+`createEvaluator`, `asJudge`, and `asAnalyst` are provider-independent exports from
+`@tangle-network/agent-eval/evaluation` (also re-exported from `/jev`).
+`createEvaluator({ execute, receipt })` meters a typed asynchronous function.
+It does not require a Jev response, probability output, prompt, or provider SDK.
+
+`jevEvaluator` adds native protocol validation and optional `acceptModel(requested,
+served)` policy. It preserves the reported model instead of guessing alias rules.
+Router independently enforces its supported model and pricing policy.
+
+## Adapt the same observation, without another model call
+
+`asJudge({ name, version, dimensions, evaluate, map, record? })` returns the existing
+`JudgeConfig`. The evaluator receives `{ artifact, scenario }` and execution context.
+`map(value, input)` returns the application's `JudgeScore` on its chosen scale.
+`record(result, input)` can persist the full distribution and receipt before reduction.
+
+`asAnalyst({ id, version, description, inputKind, cost, evaluate, map, record? })`
+returns the existing `Analyst`. The evaluator receives the input, evaluation context,
+and analyst context. `map(value, input, analystContext)` creates evidence-backed
+findings. Use the existing `makeFinding` factory and real event/span/artifact references.
+An empty finding list is valid; an inference failure is not a clean review.
+
+The optional `jevJudge` and `jevAnalyst` conveniences accept static questions or a
+question-producing function. State renderers may be async. Judge renderers receive
+the evaluation context; analyst renderers and finding mappers receive the effective
+cancellation/deadline signal. Rendering must honor that signal during external work.
+Both conveniences accept a `record` callback for the complete observation.
+
+For a numeric rubric, `jevJudge` defaults to `normalizedJevScore`: equally spaced
+score expectations on [0,1], noul values unchanged, and an optional weighted mean.
+It emits no canned notes. Supply `map` for choice utilities, different scales, or
+critical-failure policies. Dynamic questions and custom mappings require explicit
+stable output `dimensions`; changing intermediate questions must not silently change
+the metric being compared. Bump `version` when opaque renderers or mappings change.
+Optional undefined fields from SDK builders hash like the JSON they send. Invalid
+JSON evidence, including Map, Date, cycles, and non-finite numbers, is rejected rather
+than silently changed before inference. Convert timestamps explicitly to strings.
+
+## Execution and accounting
+
+Use the caller's existing `costLedger`, signal, run tags, and phase. A capped ledger
+requires a genuine transport-enforced maximum charge, not a guessed cost ceiling.
+One injected call represents one paid attempt; do not hide retries at multiple layers.
+An idempotency header is correlation, not proof of upstream inference deduplication.
+Router charges the inference. Eval records attribution and must not charge it again.
+
+The shared analyst adapter uses an explicit `AnalystContext.costLedger` first. If
+none is supplied, an explicit `budgetUsd` creates an account for that invocation.
+Otherwise the evaluator keeps its configured ledger, including its cumulative cap
+across direct calls, judges, and analysts. An absent analyst budget never creates a
+fresh unlimited account that overrides the configured one. This precedence is the
+same for Jev and other classifiers. A per-analysis budget replaces the default
+account; it is not an additional child limit. Pass the shared run ledger explicitly
+when the whole run must conserve one authority. Only trusted host code should choose
+or replace that authority.
+
+`evaluate(request, { callId, costLedger, signal })` may supply the existing ledger's
+physical paid-call identity. It reaches both `receipt.callId` and the transport's
+`idempotencyKey`. Omit it for a newly allocated identity. Duplicate pending or settled
+calls in the same ledger are refused before another dispatch; they do not return a
+cached result. Preserve a retained observation for replay, and allocate a different
+physical-attempt identity only when a retry is explicitly authorized. This adds no
+cross-credential workflow recovery or provider-side deduplication guarantee.
+
+Usage settles before answer validation and mapping. Failed parsing or mapping never
+undoes paid work. Persisted observations remain available even if cancellation prevents
+their reduction to a decision. Unknown costs are not measured zero. `record` is a
+persistence seam, not an automatic cache: callers own storage, authorization, replay
+identity, and resume policy.
+
+## Graphs, hooks, and optimization
+
+Use the same evaluator in products, a graph analyst, an awaited local pre/post-call
+function, or a rollout checkpoint. Runtime owns those execution boundaries; Eval does
+not add a scheduler or import Runtime. Observation-only Runtime hooks are not blocking
+controls, and one external sandbox prompt may include many native model requests.
+A delivery check must run before delivery; it cannot retract streamed text or tool effects.
+
+Reuse existing campaigns and optimization methods to measure questions, context
+selection, rubric levels, and routing policies. Keep final assessment independent of
+selection and retain exact input/model/policy identities. Do not treat reported model
+confidence as demonstrated calibration or a classification as proof of root cause.
+
+## Checks
+
+Run `pnpm exec vitest run tests/jev*.test.ts tests/evaluation-authority.test.ts`,
+`pnpm typecheck`, `pnpm build`, and `pnpm verify:package`. These are contract and
+execution checks, not live-provider quality or deployment evidence. The product-integrity
+rubric lives in `examples/`, not the generic implementation, and is not a default policy.
+
+Protocol: https://docs.typesafe.ai/api
+SDK: https://github.com/typesafe-ai/typesafe-sdk-js

package/docs/produced-state.md

@@ -0,0 +1,13 @@
+# Produced state and artifact revisions
+
+`extractProducedState(events)` reduces one emission-ordered event stream to the latest observed artifact and proposal state for completion checking. Keep the original stream for history.
+
+Artifacts use the exact `name`, then `uri`, then `artifactId` as their identity. A later event for that identity replaces its content and type. Distinct output paths remain distinct even when an emitter reuses an artifact ID. No path normalization, rename, or deletion is inferred.
+
+Proposals use `proposalId`. A later rejected or pending observation must not leave an older approval eligible for scoring. Missing content on the latest observation is unknown/empty evidence; it is not filled from an older revision.
+
+This behavior correction prevents an overwritten deliverable from satisfying completion through stale text. Consumers that need every historical version should retain the input stream instead of reading the reduced arrays. First-seen identity order is preserved for deterministic output.
+
+The helper does not verify a provider transaction. Tool-call names are invocations, not successful execution receipts. An agent-written file claiming payment or delivery is not independently observed merchant or fulfillment evidence. Validate those effects through the owning integration and use the existing completion and trace-verification APIs for the required checks.
+
+Input ordering is the caller's responsibility. Do not combine unordered collectors and claim the result is a current snapshot. Unobserved external changes and deletions cannot be reconstructed from this event subset.

package/docs/profile-json-identity.md

@@ -0,0 +1,33 @@
+# Profile JSON identity
+
+`toAgentProfileJson` converts a profile's JSON document form through
+`ledger-core/canonical`, the existing owner of canonical serialization. Object
+properties whose value is `undefined` are omitted, including nested optional
+properties. Everything else must have a faithful canonical JSON representation.
+Functions, symbols, non-finite numbers, BigInt, class instances, Map, Set, sparse
+arrays, undefined array members, malformed Unicode and cycles are refused with
+`AgentProfileCellValidationError`. Custom `toJSON` functions are not a way to
+substitute different evidence.
+
+This fixes an older conversion that used `JSON.stringify` before validation:
+functions could disappear and non-finite numbers could become null before the
+profile was hashed. Callers must supply portable data rather than depend on those
+coercions. An absent measurement is not a measured null or zero.
+
+Cell dimensions preserve every own string key, including `__proto__`. A
+previously stored cell whose dimension was omitted from its digest no longer
+verifies against that dimension. Do not relabel or rewrite an old cell's digest;
+retain the original record as unverifiable and issue a fresh measurement when
+needed. Ordinary portable profiles and dimensions keep the same source hashes
+and cell IDs.
+
+`sourceProfile.hash` commits to the profile alone. `sourceProfile.kind` also
+contributes to the cell ID, so a source identity join should compare both kind
+and hash. A loose product-specific fingerprint must not claim to be a validated
+canonical AgentProfile merely because it is JSON-serializable.
+
+Regression coverage: `tests/profile-json-canonical.test.ts`, together with the
+existing `tests/agent-profile-cell.test.ts`. Run the repository typecheck, full
+suite, build and package checks before release. This document does not allocate
+or announce a package version; release metadata and downstream peer ranges must
+be updated together by the normal release process.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.183.0",
+  "version": "0.185.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": {
@@ -19,6 +19,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./jev": {
+      "types": "./dist/jev.d.ts",
+      "import": "./dist/jev.js",
+      "default": "./dist/jev.js"
+    },
     "./profile-cell": {
       "types": "./dist/profile-cell.d.ts",
       "import": "./dist/profile-cell.js",
@@ -134,6 +139,11 @@
       "import": "./dist/trace-repair/index.js",
       "default": "./dist/trace-repair/index.js"
     },
+    "./diagnosis": {
+      "types": "./dist/diagnosis/index.d.ts",
+      "import": "./dist/diagnosis/index.js",
+      "default": "./dist/diagnosis/index.js"
+    },
     "./experiment": {
       "types": "./dist/experiment/index.d.ts",
       "import": "./dist/experiment/index.js",
@@ -156,6 +166,16 @@
       "types": "./dist/adapters/http.d.ts",
       "import": "./dist/adapters/http.js",
       "default": "./dist/adapters/http.js"
+    },
+    "./evaluation": {
+      "types": "./dist/evaluation.d.ts",
+      "import": "./dist/evaluation.js",
+      "default": "./dist/evaluation.js"
+    },
+    "./jev/protocol": {
+      "types": "./dist/jev-protocol.d.ts",
+      "import": "./dist/jev-protocol.js",
+      "default": "./dist/jev-protocol.js"
     }
   },
   "bin": {
@@ -211,6 +231,7 @@
     "@arizeai/phoenix-evals": "^2.3.0",
     "@biomejs/biome": "^2.5.11",
     "@types/node": "^26.4.0",
+    "ajv": "8.20.0",
     "autoevals": "^0.3.0",
     "esbuild": "^0.28.2",
     "fast-check": "^4.9.0",

package/dist/agent-profile-cell-Cv6UA-W_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-profile-cell-Cv6UA-W_.js","names":[],"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 carries its required digest scheme. Verification accepts\n * only RFC 8785 canonical JSON, using the same encoder as every new identity.\n */\n\nimport { 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/** SHA-256 over RFC 8785 canonical JSON, excluding `contentHash` and `algo`. */\nexport type SignedManifestAlgo = 'sha256-rfc8785'\n\nexport interface SignedManifest extends HypothesisManifest {\n  /** sha256 hex of canonicalized manifest (everything except contentHash and algo). */\n  contentHash: string\n  /** Required digest scheme. Missing or unsupported schemes fail verification. */\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 * Digest a manifest after validating its scheme, excluding `contentHash` and\n * `algo`. This synchronous check can refuse a manifest before consuming data.\n */\nexport function manifestContentDigest(manifest: SignedManifest): string {\n  const { contentHash: _contentHash, algo, ...rest } = manifest\n  void _contentHash\n  if (algo !== 'sha256-rfc8785') {\n    throw new Error(`pre-registration: unsupported manifest hash algo '${String(algo)}'`)\n  }\n  return hashCanonical(rest).slice('sha256:'.length)\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  try {\n    return manifestContentDigest(m) === m.contentHash\n  } catch {\n    return false\n  }\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: unsupported manifest hash scheme or content hash mismatch')\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 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/** A cell id carries the canonical digest scheme required for verification. */\nconst CELL_ID = /^agent-profile-cell:sha256-rfc8785:[0-9a-f]{64}$/\nconst CELL_ID_PREFIX = 'agent-profile-cell:sha256-rfc8785:'\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. Unsupported digest\n * schemes are refused before comparing the material.\n */\nexport async function verifyAgentProfileCell(cell: AgentProfileCell): Promise<boolean> {\n  validateAgentProfileCell(cell)\n  const material = agentProfileCellHashMaterial(cell)\n  return cell.cellId === `${CELL_ID_PREFIX}${await hashJson(material)}`\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-rfc8785:<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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"}