@tangle-network/agent-eval 0.200.1 → 0.202.0

package/dist/wire/index.d.ts

@@ -6,7 +6,7 @@ import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";
 //#region src/wire/schemas.d.ts
-declare const RubricDimensionSchema: z.ZodObject<{
+export declare const RubricDimensionSchema: z.ZodObject<{
   id: z.ZodString;
   description: z.ZodString;
   weight: z.ZodDefault<z.ZodNumber>;
@@ -17,7 +17,7 @@ declare const FailureModeSchema: z.ZodObject<{
   id: z.ZodString;
   description: z.ZodString;
 }, z.core.$strip>;
-declare const RubricSchema: z.ZodObject<{
+export declare const RubricSchema: z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   systemPrompt: z.ZodString;
@@ -37,7 +37,7 @@ declare const RubricSchema: z.ZodObject<{
     description: z.ZodString;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
-declare const JudgeRequestSchema: z.ZodObject<{
+export declare const JudgeRequestSchema: z.ZodObject<{
   rubricName: z.ZodOptional<z.ZodString>;
   rubric: z.ZodOptional<z.ZodObject<{
     name: z.ZodString;
@@ -63,7 +63,7 @@ declare const JudgeRequestSchema: z.ZodObject<{
   context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-declare const JudgeResultSchema: z.ZodObject<{
+export declare const JudgeResultSchema: z.ZodObject<{
   composite: z.ZodNumber;
   dimensions: z.ZodRecord<z.ZodString, z.ZodNumber>;
   failureModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -84,7 +84,7 @@ declare const RubricInfoSchema: z.ZodObject<{
   failureModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
   rubricVersion: z.ZodString;
 }, z.core.$strip>;
-declare const ListRubricsResponseSchema: z.ZodObject<{
+export declare const ListRubricsResponseSchema: z.ZodObject<{
   rubrics: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
@@ -97,13 +97,13 @@ declare const ListRubricsResponseSchema: z.ZodObject<{
     rubricVersion: z.ZodString;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-declare const VersionResponseSchema: z.ZodObject<{
+export declare const VersionResponseSchema: z.ZodObject<{
   package: z.ZodString;
   version: z.ZodString;
   wireVersion: z.ZodString;
   apiSurface: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
-declare const HealthResponseSchema: z.ZodObject<{
+export declare const HealthResponseSchema: z.ZodObject<{
   status: z.ZodLiteral<"ok">;
   uptimeSec: z.ZodNumber;
 }, z.core.$strip>;
@@ -113,7 +113,7 @@ declare const HealthResponseSchema: z.ZodObject<{
  * wire schema so non-TypeScript clients can validate without depending
  * on internal types.
  */
-declare const TraceEventSchema: z.ZodObject<{
+export declare const TraceEventSchema: z.ZodObject<{
   eventId: z.ZodString;
   runId: z.ZodString;
   spanId: z.ZodOptional<z.ZodString>;
@@ -130,7 +130,7 @@ declare const TraceEventSchema: z.ZodObject<{
   timestamp: z.ZodNumber;
   payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
-declare const TracesIngestRequestSchema: z.ZodObject<{
+export declare const TracesIngestRequestSchema: z.ZodObject<{
   events: z.ZodArray<z.ZodObject<{
     eventId: z.ZodString;
     runId: z.ZodString;
@@ -149,7 +149,7 @@ declare const TracesIngestRequestSchema: z.ZodObject<{
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
-declare const TracesIngestResponseSchema: z.ZodObject<{
+export declare const TracesIngestResponseSchema: z.ZodObject<{
   accepted: z.ZodNumber;
   rejected: z.ZodNumber;
   errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -157,7 +157,7 @@ declare const TracesIngestResponseSchema: z.ZodObject<{
     message: z.ZodString;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
-declare const FeedbackTrajectorySchema: z.ZodObject<{
+export declare const FeedbackTrajectorySchema: z.ZodObject<{
   id: z.ZodString;
   projectId: z.ZodOptional<z.ZodString>;
   scenarioId: z.ZodOptional<z.ZodString>;
@@ -282,38 +282,38 @@ declare const FeedbackTrajectorySchema: z.ZodObject<{
   updatedAt: z.ZodOptional<z.ZodString>;
   metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-declare const FeedbackIngestResponseSchema: z.ZodObject<{
+export declare const FeedbackIngestResponseSchema: z.ZodObject<{
   id: z.ZodString;
   persisted: z.ZodBoolean;
 }, z.core.$strip>;
-type TraceEvent = z.infer<typeof TraceEventSchema>;
-type TracesIngestRequest = z.infer<typeof TracesIngestRequestSchema>;
-type TracesIngestResponse = z.infer<typeof TracesIngestResponseSchema>;
-type FeedbackTrajectory = z.infer<typeof FeedbackTrajectorySchema>;
-type FeedbackIngestResponse = z.infer<typeof FeedbackIngestResponseSchema>;
-declare const ErrorResponseSchema: z.ZodObject<{
+export type TraceEvent = z.infer<typeof TraceEventSchema>;
+export type TracesIngestRequest = z.infer<typeof TracesIngestRequestSchema>;
+export type TracesIngestResponse = z.infer<typeof TracesIngestResponseSchema>;
+export type FeedbackTrajectory = z.infer<typeof FeedbackTrajectorySchema>;
+export type FeedbackIngestResponse = z.infer<typeof FeedbackIngestResponseSchema>;
+export declare const ErrorResponseSchema: z.ZodObject<{
   error: z.ZodObject<{
     code: z.ZodString;
     message: z.ZodString;
     details: z.ZodOptional<z.ZodUnknown>;
   }, z.core.$strip>;
 }, z.core.$strip>;
-type RubricDimension = z.infer<typeof RubricDimensionSchema>;
-type FailureMode = z.infer<typeof FailureModeSchema>;
-type Rubric = z.infer<typeof RubricSchema>;
-type JudgeRequest = z.infer<typeof JudgeRequestSchema>;
-type JudgeResult = z.infer<typeof JudgeResultSchema>;
-type RubricInfo = z.infer<typeof RubricInfoSchema>;
-type ListRubricsResponse = z.infer<typeof ListRubricsResponseSchema>;
-type VersionResponse = z.infer<typeof VersionResponseSchema>;
-type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+export type RubricDimension = z.infer<typeof RubricDimensionSchema>;
+export type FailureMode = z.infer<typeof FailureModeSchema>;
+export type Rubric = z.infer<typeof RubricSchema>;
+export type JudgeRequest = z.infer<typeof JudgeRequestSchema>;
+export type JudgeResult = z.infer<typeof JudgeResultSchema>;
+export type RubricInfo = z.infer<typeof RubricInfoSchema>;
+export type ListRubricsResponse = z.infer<typeof ListRubricsResponseSchema>;
+export type VersionResponse = z.infer<typeof VersionResponseSchema>;
+export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
 /**
  * Bump the major on any breaking change to a request/response schema — the
  * Python client compares majors and refuses a mismatch. Bump the minor when a
  * response value changes meaning without changing its shape, which a client
  * can detect but does not have to act on.
  */
-declare const WIRE_VERSION = "1.1.0";
+export declare const WIRE_VERSION = "1.1.0";
 /**
  * The digest scheme `hashRubric` mints, named inside the value it produces.
  * A consumer holding a tag from an earlier release reads a different scheme
@@ -321,7 +321,7 @@ declare const WIRE_VERSION = "1.1.0";
  * changed" — the two are indistinguishable when the value is an untagged hex
  * string.
  */
-declare const RUBRIC_VERSION_SCHEME = "sha256-rfc8785";
+export declare const RUBRIC_VERSION_SCHEME = "sha256-rfc8785";
 /**
  * Stable identity of a rubric, as `<name>@sha256-rfc8785:<hex>`. Two scores
  * are comparable when this matches exactly.
@@ -331,17 +331,17 @@ declare const RUBRIC_VERSION_SCHEME = "sha256-rfc8785";
  * property of the value alone — so the same rubric produces the same tag on
  * every machine, which a locale-collated key order does not guarantee.
  */
-declare function hashRubric(rubric: Rubric): string;
+export declare function hashRubric(rubric: Rubric): string;
 //#endregion
 //#region src/wire/handlers.d.ts
 /** Caller-fixable error. The transport renders this to 4xx + ErrorResponse. */
-declare class WireError extends Error {
+export declare class WireError extends Error {
   readonly code: string;
   readonly status: number;
   readonly details?: unknown;
   constructor(code: string, message: string, status?: number, details?: unknown);
 }
-interface HandleJudgeOptions {
+export interface HandleJudgeOptions {
   costLedger?: CostLedgerHandle;
   costPhase?: string;
   /**
@@ -355,9 +355,9 @@ interface HandleJudgeOptions {
   pricing?: CustomTokenPricing;
   signal?: AbortSignal;
 }
-declare function handleJudge(req: JudgeRequest, options?: HandleJudgeOptions): Promise<JudgeResult>;
-declare function handleListRubrics(): ListRubricsResponse;
-declare function handleVersion(): VersionResponse;
+export declare function handleJudge(req: JudgeRequest, options?: HandleJudgeOptions): Promise<JudgeResult>;
+export declare function handleListRubrics(): ListRubricsResponse;
+export declare function handleVersion(): VersionResponse;
 /**
  * Pluggable stores the wire layer routes ingestion writes into. Both
  * are optional — when omitted, the corresponding endpoint returns 503.
@@ -366,7 +366,7 @@ declare function handleVersion(): VersionResponse;
  * `FileSystemFeedbackTrajectoryStore` here. Tests substitute in-memory
  * stores.
  */
-interface IngestionStores {
+export interface IngestionStores {
   traceStore?: TraceStore;
   feedbackStore?: FeedbackTrajectoryStore;
 }
@@ -380,13 +380,13 @@ interface IngestionStores {
  * de-duplicate by `eventId` downstream — production traces frequently
  * land via at-least-once buses (Kafka, SQS) where dedup is unavoidable.
  */
-declare function handleTracesIngest(req: TracesIngestRequest, stores: IngestionStores): Promise<TracesIngestResponse>;
+export declare function handleTracesIngest(req: TracesIngestRequest, stores: IngestionStores): Promise<TracesIngestResponse>;
 /**
  * `POST /v1/feedback` — accept a single `FeedbackTrajectory` from the
  * production runtime. Idempotent on `id`: re-posting the same trajectory
  * replaces the prior record.
  */
-declare function handleFeedbackIngest(req: FeedbackTrajectory, stores: IngestionStores): Promise<FeedbackIngestResponse>;
+export declare function handleFeedbackIngest(req: FeedbackTrajectory, stores: IngestionStores): Promise<FeedbackIngestResponse>;
 //#endregion
 //#region node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/specification-extension.d.ts
 type IExtensionName = `x-${string}`;
@@ -703,7 +703,7 @@ interface SecurityRequirementObject {
 }
 //#endregion
 //#region src/wire/openapi.d.ts
-declare function buildOpenApi(packageVersion: string): OpenAPIObject;
+export declare function buildOpenApi(packageVersion: string): OpenAPIObject;
 //#endregion
 //#region src/wire/rpc.d.ts
 interface RpcRequest {
@@ -725,17 +725,17 @@ interface RpcOptions {
   chat?: ChatClient;
   judgeModel?: string;
 }
-declare function dispatchRpc(req: RpcRequest, options?: RpcOptions): Promise<RpcSuccess | RpcError>;
+export declare function dispatchRpc(req: RpcRequest, options?: RpcOptions): Promise<RpcSuccess | RpcError>;
 /** Read one JSON request from stdin, write one JSON response to stdout. */
-declare function runRpcOnce(method?: string, options?: RpcOptions): Promise<number>;
+export declare function runRpcOnce(method?: string, options?: RpcOptions): Promise<number>;
 /** Read JSONL requests from stdin, write JSONL responses to stdout. */
-declare function runRpcBatch(method?: string, options?: RpcOptions): Promise<number>;
+export declare function runRpcBatch(method?: string, options?: RpcOptions): Promise<number>;
 //#endregion
 //#region src/wire/rubrics.d.ts
 /** Get a built-in rubric by name, or undefined. */
-declare function getBuiltinRubric(name: string): Rubric | undefined;
+export declare function getBuiltinRubric(name: string): Rubric | undefined;
 /** List built-in rubrics with their stable versions. */
-declare function listBuiltinRubrics(): {
+export declare function listBuiltinRubrics(): {
   name: string;
   description: string;
   dimensions: {
@@ -772,14 +772,14 @@ interface CreateAppOptions {
     bearer: string | ((token: string) => boolean | Promise<boolean>);
   };
 }
-declare function createApp(opts?: CreateAppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function createApp(opts?: CreateAppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
 interface ServeOptions extends CreateAppOptions {
   /** Default 5005. */
   port?: number;
   /** Default '127.0.0.1'. Set to '0.0.0.0' to listen on all interfaces. */
   host?: string;
 }
-declare function startServer(opts?: ServeOptions): ServerType;
+export declare function startServer(opts?: ServeOptions): ServerType;
 interface StartedServer {
   server: ServerType;
   /** The OS-assigned port. When opts.port was 0, this is the actual port the
@@ -796,7 +796,7 @@ interface StartedServer {
  * listening and surfaces the resolved bound port. Use this from smoke tests
  * (`startServerAsync({ port: 0 })`) and any caller that needs to dial back.
  */
-declare function startServerAsync(opts?: ServeOptions): Promise<StartedServer>;
+export declare function startServerAsync(opts?: ServeOptions): Promise<StartedServer>;
 //#endregion
-export { ErrorResponse, ErrorResponseSchema, FailureMode, FeedbackIngestResponse, FeedbackIngestResponseSchema, FeedbackTrajectory, FeedbackTrajectorySchema, HandleJudgeOptions, HealthResponseSchema, IngestionStores, JudgeRequest, JudgeRequestSchema, JudgeResult, JudgeResultSchema, ListRubricsResponse, ListRubricsResponseSchema, RUBRIC_VERSION_SCHEME, type RpcOptions, Rubric, RubricDimension, RubricDimensionSchema, RubricInfo, RubricSchema, type ServeOptions, type StartedServer, TraceEvent, TraceEventSchema, TracesIngestRequest, TracesIngestRequestSchema, TracesIngestResponse, TracesIngestResponseSchema, VersionResponse, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };
+export type { RpcOptions, ServeOptions, StartedServer };
 //# sourceMappingURL=index.d.ts.map

package/dist/wire/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/specification-extension.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/oas-common.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/openapi31.d.ts","../../src/wire/openapi.ts","../../src/wire/rpc.ts","../../src/wire/rubrics.ts","../../src/wire/server.ts"],"x_google_ignoreList":[2,3,4],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["WireFeedbackTrajectory"],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/specification-extension.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/oas-common.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.1/node_modules/openapi3-ts/dist/model/openapi31.d.ts","../../src/wire/openapi.ts","../../src/wire/rpc.ts","../../src/wire/rubrics.ts","../../src/wire/server.ts"],"x_google_ignoreList":[2,3,4],"mappings":"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"}

package/dist/wire/index.js

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

package/docs/evaluator-construction.md

@@ -0,0 +1,71 @@
+# Evaluator construction: plan, execute, audit
+
+Use existing Runtime execution and Eval measurements. A product integration should not implement another error-bound formula, check counter, or per-call intent/result protocol.
+
+## Plan before spending
+
+```ts
+import { planEvaluatorAudit } from '@tangle-network/agent-eval/meta-eval'
+
+const policy = {
+  confidence: 0.95,
+  maxFalseAcceptanceRate: 0.1,
+  maxFalseRejectionRate: 0.1,
+}
+const requirements = planEvaluatorAudit({ policy })
+// minimumIndependentUnits: 42 per class for this policy, even with zero errors.
+
+const capacity = planEvaluatorAudit({ policy, controls })
+if (!capacity.sufficient) {
+  // Collect enough authorized, independent evidence before constructing a checker.
+  // Each class reports its actual count and additionalIndependentUnits.
+}
+```
+
+A control has `id`, `independentUnitId`, `expected: 'accept' | 'reject'`, and `exposure: 'fresh' | 'development'`. It has no observed judgment. Repeated variants share a source identity. Any development exposure excludes that entire source unit, exactly as in admission.
+
+This is a best-case eligibility floor, not power, permission to spend, or an admission certificate. A zero error-probability limit has no finite sample solution. `auditEvaluator` and `auditProbabilityPolicy` still require actual independent evidence. Their existing report and digest contracts are unchanged.
+
+The existing `evaluatorAdmissionPolicySchema` and `evaluatorAuditObservationSchema` are exported from `/meta-eval`. Derive consumer contracts and types from these instead of copying policy fields or decision enums.
+
+## Retain external check calls
+
+```ts
+import { createRetainedDispatch } from '@tangle-network/agent-eval/campaign'
+
+const checks = createRetainedDispatch({
+  runDir,                      // one private, durable logical episode directory
+  scope: frozenManifest,       // authority, code/decoder revision, environment and inputs
+  limits: { development: 20, audit: 84 },
+  parse: validateRuntimeResult,
+})
+
+const result = await checks.run({
+  lane: 'audit',
+  input: { evaluatorDigest, caseId, inputDigest },
+  signal,
+  dispatch: () => executeIsolatedCheck(),
+})
+```
+
+The limits above illustrate disjoint allowances; choose them from the approved experiment budget and required roster. Development cannot consume the audit reserve. Counts include uncertain calls. They are not dollars and do not replace the existing spend ledger or provider-enforced ceilings.
+
+`result.succeeded` means an external-call result was retained, not that the task or checker passed. The value may itself record an execution failure. A settled result replays with `replayed: true`; it is parsed and its digest checked on every read. A result retained before a settlement lock conflict is reconciled by dispatch ID on retry, without repeating the external call. Concurrent callers on one handle share an in-flight call. Independent processes use the existing `CampaignStorage.append` compare-and-swap.
+
+A rejected dispatch or cancelled in-flight call returns `outcome_unknown` with its diagnostic and keeps the allowance committed. A process crash or result loss after intent also leaves `outcome_unknown`; a new caller does not repeat it or refund its allowance. A corrupt/missing settled receipt, changed scope, changed limits, or torn history is an error, not a fresh run. Keep the same directory on retry; changing the directory is a new episode, so the existing product job/authority owner must prevent that from becoming a budget reset.
+
+The filesystem adapter fsyncs through the existing storage primitive. An in-memory adapter remains in-memory and cannot establish reboot recovery. Caller-owned storage must provide the documented atomic append contract. Keep the directory and result files outside generated code's permissions; content hashes are integrity checks, not a substitute for tenant authorization or a trusted storage boundary.
+
+`runEval` still owns scheduling, judges, concurrency and campaign reports. Wrap only the external dispatch that needs uncertain-result protection. The primitive does not introduce a scheduler, database, execution backend or inferred price. Reference and generated-checker execution use the same mechanism.
+
+The caller binds every behavior-affecting dependency and decoder revision into scope, validates the complete JSON result, and captures request state before dispatch. Noncanonical or non-round-tripping result encodings are refused rather than silently coerced.
+
+## Prove the persistence path
+
+```sh
+pnpm exec tsx scripts/prove-retained-dispatch.ts
+```
+
+This executes real child processes against filesystem storage, kills an owner after its external write, and checks contention, completed replay, unknown-outcome retention, settlement-lock recovery, independent audit allowance, scope changes, cancellation, receipt identity and corrupted evidence. The maintained test suite runs the same proof. It makes no model calls and is not a semantic evaluator-quality or customer-savings benchmark.
+
+An integration still needs its real Runtime/Sandbox execution, independent audit authorities, approved fresh evidence, complete cost reconciliation, and controlled activation proof. This API does not manufacture any of them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.200.1",
+  "version": "0.202.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": {
@@ -224,53 +224,35 @@
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^9.1.0",
     "@hono/node-server": "^2.1.1",
-    "@tangle-network/agent-core": "^0.9.6",
-    "@tangle-network/agent-interface": "^2.0.0",
-    "@tangle-network/agent-trace-contract": "^1.3.0",
-    "hono": "^4.13.5",
+    "@tangle-network/agent-core": "^0.10.2",
+    "@tangle-network/agent-interface": "^2.13.1",
+    "@tangle-network/agent-trace-contract": "^2.0.0",
+    "hono": "^4.13.9",
     "linear-sum-assignment": "1.0.9",
     "re2js": "2.8.6",
-    "smol-toml": "1.8.0",
-    "zod": "4.5.4"
+    "smol-toml": "1.9.0",
+    "zod": "4.6.5"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
-    "@arizeai/phoenix-evals": "^2.3.0",
-    "@biomejs/biome": "^2.5.11",
-    "@types/node": "^26.4.0",
+    "@arizeai/phoenix-evals": "^2.6.0",
+    "@biomejs/biome": "^2.5.14",
+    "@types/node": "^26.6.2",
     "ajv": "8.20.0",
     "autoevals": "^0.3.0",
     "esbuild": "^0.28.2",
-    "fast-check": "^4.9.0",
+    "fast-check": "^4.10.2",
     "husky": "^9.1.7",
     "lib-r-math.js": "^3.0.2",
-    "lint-staged": "^17.4.1",
+    "lint-staged": "^17.5.1",
     "openapi3-ts": "^4.6.1",
-    "oxc-parser": "^0.147.0",
+    "oxc-parser": "^0.151.0",
     "publint": "^0.3.24",
-    "tsdown": "^0.22.14",
-    "tsx": "^4.23.12",
+    "tsdown": "^0.23.0",
+    "tsx": "^4.23.15",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.11",
-    "yaml": "2.9.0"
-  },
-  "pnpm": {
-    "minimumReleaseAge": 4320,
-    "minimumReleaseAgeExclude": [
-      "@tangle-network/*",
-      "esbuild",
-      "vite",
-      "zod@4.5.4"
-    ],
-    "overrides": {
-      "@arizeai/openinference-core>@opentelemetry/core": "^2.10.0",
-      "esbuild@>=0.27.3 <0.28.1": "^0.28.1",
-      "fast-uri": "3.1.6",
-      "js-yaml": "4.3.1",
-      "postcss@<8.5.18": "^8.5.18",
-      "vite@>=7.0.0 <=7.3.4": "^7.3.5",
-      "ws@>=8.0.0 <8.21.0": "^8.21.0"
-    }
+    "vitest": "^5.0.1",
+    "yaml": "2.9.1"
   },
   "engines": {
     "node": ">=20.19.0"
@@ -284,5 +266,5 @@
     ]
   },
   "license": "MIT",
-  "packageManager": "pnpm@10.34.5"
+  "packageManager": "pnpm@12.6.0"
 }