@tangle-network/agent-eval 0.221.8 → 0.222.0

package/dist/wire/index.d.ts

@@ -1,11 +1,10 @@
-import { m as CustomTokenPricing, o as CostLedgerHandle } from "../cost-ledger-C1W3ICmP.js";
-import { x as ChatClient } from "../types-B_IFcKp5.js";
-import { s as TraceStore } from "../store-B3nWRy3B.js";
-import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-CYVJXolG.js";
+import { m as CustomTokenPricing, o as CostLedgerHandle } from "../cost-ledger-Czro9wmo.js";
+import { x as ChatClient } from "../types-0KglnQ9o.js";
+import { s as TraceStore } from "../store-CMs5wGXP.js";
+import { m as FeedbackTrajectoryStore } from "../feedback-trajectory-SBGncrCP.js";
 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<{
   id: z.ZodString;
   description: z.ZodString;
@@ -114,14 +113,14 @@ export declare const TraceEventSchema: z.ZodObject<{
   runId: z.ZodString;
   spanId: z.ZodOptional<z.ZodString>;
   kind: z.ZodEnum<{
-    budget_breach: "budget_breach";
-    budget_decrement: "budget_decrement";
-    custom: "custom";
+    policy_violation: "policy_violation";
     error: "error";
+    custom: "custom";
     log: "log";
-    policy_violation: "policy_violation";
-    redaction_applied: "redaction_applied";
+    budget_decrement: "budget_decrement";
+    budget_breach: "budget_breach";
     state_mutation: "state_mutation";
+    redaction_applied: "redaction_applied";
   }>;
   timestamp: z.ZodNumber;
   payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -132,14 +131,14 @@ declare const TracesIngestRequestSchema: z.ZodObject<{
     runId: z.ZodString;
     spanId: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
-      budget_breach: "budget_breach";
-      budget_decrement: "budget_decrement";
-      custom: "custom";
+      policy_violation: "policy_violation";
       error: "error";
+      custom: "custom";
       log: "log";
-      policy_violation: "policy_violation";
-      redaction_applied: "redaction_applied";
+      budget_decrement: "budget_decrement";
+      budget_breach: "budget_breach";
       state_mutation: "state_mutation";
+      redaction_applied: "redaction_applied";
     }>;
     timestamp: z.ZodNumber;
     payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -165,15 +164,15 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
     id: z.ZodString;
     stepIndex: z.ZodNumber;
     artifactType: z.ZodEnum<{
-      action: "action";
+      text: "text";
       code: "code";
-      data: "data";
-      decision: "decision";
-      other: "other";
       plan: "plan";
       research: "research";
-      text: "text";
+      action: "action";
       ui: "ui";
+      decision: "decision";
+      data: "data";
+      other: "other";
     }>;
     artifact: z.ZodUnknown;
     options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
@@ -181,8 +180,8 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
       type: z.ZodString;
       risk: z.ZodOptional<z.ZodEnum<{
         high: "high";
-        low: "low";
         medium: "medium";
+        low: "low";
       }>>;
       costUsd: z.ZodOptional<z.ZodNumber>;
       externalSideEffect: z.ZodOptional<z.ZodBoolean>;
@@ -192,31 +191,31 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
     feedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
       id: z.ZodOptional<z.ZodString>;
       source: z.ZodEnum<{
-        environment: "environment";
-        judge: "judge";
-        metric: "metric";
-        policy: "policy";
         system: "system";
+        metric: "metric";
         user: "user";
+        judge: "judge";
+        environment: "environment";
+        policy: "policy";
       }>;
       kind: z.ZodEnum<{
         approve: "approve";
-        comment: "comment";
+        reject: "reject";
+        select: "select";
         edit: "edit";
-        metric_outcome: "metric_outcome";
-        policy_block: "policy_block";
         rank: "rank";
         rate: "rate";
-        reject: "reject";
+        comment: "comment";
+        metric_outcome: "metric_outcome";
+        policy_block: "policy_block";
         revision_request: "revision_request";
-        select: "select";
       }>;
       value: z.ZodUnknown;
       reason: z.ZodOptional<z.ZodString>;
       severity: z.ZodOptional<z.ZodEnum<{
         critical: "critical";
-        error: "error";
         info: "info";
+        error: "error";
         warning: "warning";
       }>>;
       createdAt: z.ZodString;
@@ -228,31 +227,31 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
   labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     source: z.ZodEnum<{
-      environment: "environment";
-      judge: "judge";
-      metric: "metric";
-      policy: "policy";
       system: "system";
+      metric: "metric";
       user: "user";
+      judge: "judge";
+      environment: "environment";
+      policy: "policy";
     }>;
     kind: z.ZodEnum<{
       approve: "approve";
-      comment: "comment";
+      reject: "reject";
+      select: "select";
       edit: "edit";
-      metric_outcome: "metric_outcome";
-      policy_block: "policy_block";
       rank: "rank";
       rate: "rate";
-      reject: "reject";
+      comment: "comment";
+      metric_outcome: "metric_outcome";
+      policy_block: "policy_block";
       revision_request: "revision_request";
-      select: "select";
     }>;
     value: z.ZodUnknown;
     reason: z.ZodOptional<z.ZodString>;
     severity: z.ZodOptional<z.ZodEnum<{
       critical: "critical";
-      error: "error";
       info: "info";
+      error: "error";
       warning: "warning";
     }>>;
     createdAt: z.ZodString;
@@ -270,8 +269,8 @@ export declare const FeedbackTrajectorySchema: z.ZodObject<{
   split: z.ZodOptional<z.ZodEnum<{
     dev: "dev";
     holdout: "holdout";
-    test: "test";
     train: "train";
+    test: "test";
   }>>;
   tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   createdAt: z.ZodString;
@@ -310,14 +309,12 @@ type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
  * can detect but does not have to act on.
  */
 export declare const WIRE_VERSION = "1.1.0";
-//#endregion
-//#region src/wire/handlers.d.ts
 /** Caller-fixable error. The transport renders this to 4xx + ErrorResponse. */
 export declare class WireError extends Error {
   readonly code: string;
   readonly status: number;
-  readonly details?: unknown;
-  constructor(code: string, message: string, status?: number, details?: unknown);
+  readonly details?: unknown | undefined;
+  constructor(code: string, message: string, status?: number, details?: unknown | undefined);
 }
 interface HandleJudgeOptions {
   costLedger?: CostLedgerHandle;
@@ -345,8 +342,6 @@ interface IngestionStores {
   traceStore?: TraceStore;
   feedbackStore?: FeedbackTrajectoryStore;
 }
-//#endregion
-//#region src/wire/rpc.d.ts
 interface RpcRequest {
   method: 'judge' | 'listRubrics' | 'version';
   params?: unknown;
@@ -367,8 +362,6 @@ interface RpcOptions {
   judgeModel?: string;
 }
 export declare function dispatchRpc(req: RpcRequest, options?: RpcOptions): Promise<RpcSuccess | RpcError>;
-//#endregion
-//#region src/wire/server.d.ts
 interface CreateAppOptions {
   /** Stores wired to the ingestion endpoints. */
   stores?: IngestionStores;
@@ -418,6 +411,5 @@ interface StartedServer {
  * (`startServerAsync({ port: 0 })`) and any caller that needs to dial back.
  */
 export declare function startServerAsync(opts?: ServeOptions): Promise<StartedServer>;
-//#endregion
 export type { ErrorResponse, FeedbackIngestResponse, HandleJudgeOptions, IngestionStores, JudgeRequest, JudgeResult, ListRubricsResponse, RpcOptions, Rubric, RubricInfo, ServeOptions, StartedServer, TracesIngestRequest, TracesIngestResponse, VersionResponse, WireFailureMode, WireFeedbackTrajectory, WireRubricDimension, WireTraceEvent };
 //# 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","../../src/wire/rpc.ts","../../src/wire/server.ts"],"mappings":";;;;;;;;cAoBa,uBAAqB,EAAA;;;;;;GAkBD,EAAA,KAAA;cAE3B,mBAAiB,EAAA;;;GAKM,EAAA,KAAA;cAIhB,cAAY,EAAA;;;;;;;;;;;;;;;;;;;GA6BL,EAAA,KAAA;cAIP,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAwBL,EAAA,KAAA;cAEb,mBAAiB,EAAA;;;;;;;;;GA6BL,EAAA,KAAA;cAInB,kBAAgB,EAAA;;;;;;;;;;GAcE,EAAA,KAAA;cAEX,2BAAyB,EAAA;;;;;;;;;;;;GAIL,EAAA,KAAA;cAIpB,uBAAqB,EAAA;;;;;GAWL,EAAA,KAAA;;;;;;;qBAiBhB,kBAAgB,EAAA;;;;;;;;;;;;;;;;GA0BD,EAAA,KAAA;cAEf,2BAAyB,EAAA;;;;;;;;;;;;;;;;;;GAQL,EAAA,KAAA;cAEpB,4BAA0B,EAAA;;;;;;;GAiBL,EAAA,KAAA;qBA2DrB,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BD,EAAA,KAAA;cAEvB,8BAA4B,EAAA;;;GAKL,EAAA,KAAA;KAExB,iBAAiB,EAAE,aAAa;KAChC,sBAAsB,EAAE,aAAa;KACrC,uBAAuB,EAAE,aAAa;KACtC,yBAAyB,EAAE,aAAa;KACxC,yBAAyB,EAAE,aAAa;qBAIvC,qBAAmB,EAAA;;;;;;GAcL,EAAA,KAAA;KAIf,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,SAAS,EAAE,aAAa;KACxB,eAAe,EAAE,aAAa;KAC9B,cAAc,EAAE,aAAa;KAC7B,aAAa,EAAE,aAAa;KAC5B,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,gBAAgB,EAAE,aAAa;;;;;;;qBAU9B;;;;qBChWA,kBAAkB;WAEX;WAEA;WACA;EAJlB,YACkB,cAChB,iBACgB,iBACA;;UAgJH;EACf,aAAa;EACb;;;;;;EAMA,OAAO;EACP;;EAEA,UAAU;EACV,SAAS;;;;;;;;;;UAsGM;EACf,aAAa;EACb,gBAAgB;;;;UC5RR;EACR;EACA;;UAGQ;EACR;;UAGQ;EACR;IAAS;IAAc;IAAiB;;;UAGzB;;EAEf,OAAO;EACP;;wBAGoB,YACpB,KAAK,YACL,UAAS,aACR,QAAQ,aAAa;;;UCNd;;EAER,SAAS;;;;;;EAMT,OAAO;;EAEP;;;;;;;;;;EAUA;IACE,mBAAmB,4BAA4B;;;wBAMnC,UAAU,OAAM,mBAAqB,0BAAA,+BAAA;UA0IpC,qBAAqB;;EAEpC;;EAEA;;wBAGc,YAAY,OAAM,eAAoB;UAUrC;EACf,QAAQ;;;;EAIR;;EAEA;;EAEA,SAAS;;;;;;;wBAQK,iBAAiB,OAAM,eAAoB,QAAQ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../src/wire/rpc.ts","../../src/wire/server.ts"],"mappings":";;;;;;;cAoBa,uBAAqB,EAAA;;;;;;GAkBD,EAAA,KAAA;cAE3B,mBAAiB,EAAA;;;GAKM,EAAA,KAAA;cAIhB,cAAY,EAAA;;;;;;;;;;;;;;;;;;;GA6BL,EAAA,KAAA;cAIP,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAwBL,EAAA,KAAA;cAEb,mBAAiB,EAAA;;;;;;;;;GA6BL,EAAA,KAAA;cAInB,kBAAgB,EAAA;;;;;;;;;;GAcE,EAAA,KAAA;cAEX,2BAAyB,EAAA;;;;;;;;;;;;GAIL,EAAA,KAAA;cAIpB,uBAAqB,EAAA;;;;;GAWL,EAAA,KAAA;;;;;;;qBAiBhB,kBAAgB,EAAA;;;;;;;;;;;;;;;;GA0BD,EAAA,KAAA;cAEf,2BAAyB,EAAA;;;;;;;;;;;;;;;;;;GAQL,EAAA,KAAA;cAEpB,4BAA0B,EAAA;;;;;;;GAiBL,EAAA,KAAA;qBA2DrB,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BD,EAAA,KAAA;cAEvB,8BAA4B,EAAA;;;GAKL,EAAA,KAAA;KAExB,iBAAiB,EAAE,aAAa;KAChC,sBAAsB,EAAE,aAAa;KACrC,uBAAuB,EAAE,aAAa;KACtC,yBAAyB,EAAE,aAAa;KACxC,yBAAyB,EAAE,aAAa;qBAIvC,qBAAmB,EAAA;;;;;;GAcL,EAAA,KAAA;KAIf,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,SAAS,EAAE,aAAa;KACxB,eAAe,EAAE,aAAa;KAC9B,cAAc,EAAE,aAAa;KAC7B,aAAa,EAAE,aAAa;KAC5B,sBAAsB,EAAE,aAAa;KACrC,kBAAkB,EAAE,aAAa;KACjC,gBAAgB,EAAE,aAAa;;;;;;;qBAU9B;;qBChWA,kBAAkB;WAEX;WAEA;WACA;EAHA,YAAA,cAChB,iBACgB,iBACA;;UAgJH;EACf,aAAa;EACb;;;;;;EAMA,OAAO;EACP;;EAEA,UAAU;EACV,SAAS;;;;;;;;;;UAsGM;EACf,aAAa;EACb,gBAAgB;;UC5RR;EACR;EACA;;UAGQ;EACR;;UAGQ;EACR;IAAS;IAAc;IAAiB;;;UAGzB;;EAEf,OAAO;EACP;;wBAGoB,YACpB,KAAK,YACL,UAAS,aACR,QAAQ,aAAa;UCNd;;EAER,SAAS;;;;;;EAMT,OAAO;;EAEP;;;;;;;;;;EAUA;IACE,mBAAmB,4BAA4B;;;wBAMnC,UAAU,OAAM,mBAAqB,0BAAA,+BAAA;UA0IpC,qBAAqB;;EAEpC;;EAEA;;wBAGc,YAAY,OAAM,eAAoB;UAUrC;EACf,QAAQ;;;;EAIR;;EAEA;;EAEA,SAAS;;;;;;;wBAQK,iBAAiB,OAAM,eAAoB,QAAQ"}

package/dist/wire/index.js

@@ -1,2 +1 @@
-import { a as dispatchRpc, c as WireError, d as FeedbackTrajectorySchema, f as TraceEventSchema, n as startServer, p as WIRE_VERSION, r as startServerAsync, t as createApp, u as ErrorResponseSchema } from "../server-ChhXPCgX.js";
-export { ErrorResponseSchema, FeedbackTrajectorySchema, TraceEventSchema, WIRE_VERSION, WireError, createApp, dispatchRpc, startServer, startServerAsync };
+export { u as ErrorResponseSchema, d as FeedbackTrajectorySchema, f as TraceEventSchema, p as WIRE_VERSION, c as WireError, t as createApp, a as dispatchRpc, n as startServer, r as startServerAsync } from "../server-DA6h3co5.js";

package/docs/eval-surface-map.md

@@ -107,6 +107,17 @@ Use registered gates for inference across independent source units; their `paire
 `distribution` is the `SeriesDistribution` value `summarizeNumberSeries` returns: `n`, `min`, `p50`, `p90`, `max`, and `sum` over the exact scores the mean was taken over.
 Quantiles use the nearest-rank definition, so every reported quantile is a score the campaign measured.
 
+`summarizeNumberSeries(values, { percentiles: [95, 99.9], medianInterval: { criticalValue: 1.96 } })`
+also reports the requested percentiles on a 0–100 scale and a deterministic median rank band.
+The band uses ranks `floor(n/2 − criticalValue·sqrt(n)/2)` and
+`ceil(n/2 + 1 + criticalValue·sqrt(n)/2)`, clamped to the observed sample.
+Its `method`, `criticalValue`, `sampleSize`, and ranks describe the evidence;
+it is a normal approximation over order statistics, not a bootstrap interval or a promotion test.
+An empty sample returns `null`; a singleton band is a point and establishes no spread.
+The optional fields appear only when requested, so existing campaign distributions retain their shape.
+Options must use finite, in-range percentiles and a finite, nonnegative critical value, even for an empty sample.
+Calls with options also reject non-finite observations and sum overflow rather than serializing missing numbers as `null`.
+
 Read the distribution before you read the mean.
 A mean and an interval alone cannot separate a bimodal judge from a tight one, and cannot show the outlier that carried the mean.
 Six cells scoring `0, 0, 0, 1, 1, 1` and six cells scoring `0.5` report the same mean; only `min` and `max` tell them apart.
@@ -155,6 +166,10 @@ The receipt records the stage (`dispatch` or `judge`), the serialized error, the
 `abortOnCellError: true` stops the campaign on the first failed cell; the default keeps the remaining schedule running and returns the failed cell.
 
 `cellRetry: { attempts, retryable }` opts in to bounded in-run retry.
+An optional `retryResult(artifact)` retries a measured failed result without turning it into a dispatch error.
+Each attempt retains its artifact; only the final attempt enters the result and reusable cache.
+Use `onCellSettled(cell, scenario)` for completion-order progress after each final cell is persisted, including cache hits.
+Campaign cancellation returns the settled prefix after active dispatches drain; dispatch or accounting failures still reject.
 A failed attempt that `retryable` accepts is dispatched again in the same slot (same `cellId`, same seed) until it succeeds or `attempts` is exhausted.
 Use `transientDispatchFailure()` as the predicate to retry only dispatch-stage transport failures (502/503/504, dropped streams, admission rejections) and never judge-stage failures.
 Every attempt charges the shared cost ledger, so the final cell's `costUsd` and `costCallIds` cover all attempts.

package/docs/rollout.md

@@ -13,16 +13,81 @@ Every invariant is enforced once, at the waist, so no sink can be reached by a p
 SOURCES                      WAIST                         SINKS
 RunRecord × trace   ─┐                          ┌─→ SFT chat JSONL        (toSftRows)
 opencode sqlite     ─┤                          ├─→ reward rows           (toRewardRows)
-Claude Code jsonl   ─┼─→  tangle.rollout.v1 ────┼─→ Prime Intellect       (toVerifiersRolloutOutputs)
+Claude/Codex jsonl   ─┼─→  tangle.rollout.v1 ────┼─→ Prime Intellect       (toVerifiersRolloutOutputs)
 domain backfills    ─┤     (RolloutLine)        ├─→ OpenAI RFT            (toRftItems)
 Harbor ATIF import  ─┘                          ├─→ DPO / GRPO / PRM       (rl exporters)
                                                 ├─→ HF dataset release    (buildHfDataset)
-                                                └─→ Harbor ATIF export    (toHarborTrajectory)
+                                                ├─→ Harbor ATIF export    (toHarborTrajectory)
+                                                └─→ Tinker Datums         (toTinkerDatumRows)
 ```
 
 A source's job is to produce a `RolloutLine` and nothing else.
 A sink's job is to consume `MintedRolloutLine[]` and nothing else — no sink reads a `RunRecord` or a `TraceStore`, because that would be a second door into training data with no gate on it.
 
+## Verified episodes as Harbor task directories
+
+`writeHarborTask` consumes one `MintedRolloutLine`, its existing `CodeSurface`, and a
+merge identity. It writes a runnable task directory, separate from the ATIF trajectory
+interchange. The writer never runs Git, starts an environment, fetches a repository,
+or executes a verifier. Execution stays with the caller. The caller must bound
+`verify` execution and honor the optional abort signal; the writer does not create
+another process or callback timeout mechanism.
+
+The caller supplies a digest-pinned image, a Git bundle containing only the exact
+base and its ancestors, task instructions, and three verifier scripts. The image
+must already contain Git and the scripts' prerequisites, without the reference
+answer. Its configured user must be able to clone into `/workspace/repo`; the
+writer does not change that user or install dependencies. The Linux Dockerfile
+copies the base-only bundle as read-only `0444`, so a nonroot configured user can
+read it without owning it. `/tmp/base.bundle` remains in the image; the build does
+not require removing a root-owned file from a sticky temporary directory.
+The generated Dockerfile checks out the pinned base. Only this Dockerfile
+and base bundle enter the agent's build context. No reference patch, candidate
+checkout, episode transcript, or merge checkout is copied into that context.
+
+Before `task.toml` becomes visible, a trusted `verify` callback inspects the staged
+files and returns the existing `CompletionVerdict` for the supplied digest-bound
+`taskId`. That identity includes the canonical episode hash, rollout/task identity,
+base/head trees and commits, merged diff anchor, merge commit, and every generated
+file's bytes. Five measured requirements must each be correct, satisfied, and
+supported by receipts:
+
+- `base-bundle`: actual bundle closure is the exact base/ancestors, with no answer
+  objects, additional refs, or embedded reference material.
+- `acceptance`: the provided acceptance command passed on this exact candidate.
+- `production-delta`: the caller's production-line census observed a strict
+  decrease against this base, with the production scope explicitly identified.
+- `dangling-references`: the caller's actual reference checker observed none.
+- `merge-followup`: the exact candidate was merged, this base is merge's first
+  parent, and an explicitly closed followup interval was checked for fix-forward
+  changes. A missing/open interval is unknown; a merge alone does not prove this.
+
+The callback must bind its receipts to the actual file hashes and source identity,
+not titles, inferred keywords, an unrelated pass, or a timestamp heuristic. Eval
+checks the callback's contract and rechecks staged files; it cannot independently
+certify caller claims or training-provider eligibility. Reward must already be 1,
+completed and screened, without truncation or an error. Unknown evidence refuses
+publication. Admission failures retain a diagnostic directory without `task.toml`.
+An existing output path is never overwritten.
+
+Harbor's [task format](https://docs.harborframework.com/tasks/overview) and
+[configuration](https://docs.harborframework.com/tasks/configuration) own the layout.
+The task contains `task.toml`, `instruction.md`, `environment/`, and `tests/`.
+The generated `tests/test.sh` first writes reward 0, runs all three commands, and
+writes reward 1 only after their conjunction passes. Harbor's normal paths are the
+defaults; explicit project/tests/reward directory arguments allow the same script
+to be exercised through an actual local process boundary. Failure or unknown
+measurement must exit nonzero in caller scripts. The live technical reward does
+not assert a new agent attempt has subsequently merged; later-merge/no-fix-forward
+eligibility remains a separate, closed observation before that attempt is admitted
+as another episode. Provider consent and split/release policy remain separate.
+
+Load the emitted directory through `createHarborBenchmarkAdapter` from
+`@tangle-network/agent-eval/benchmarks`, and execute it through the caller's existing
+Harbor runner. A directory written, a loader pass, and a successful environment
+run are distinct evidence levels. This writer does not turn metadata into a
+passing execution or manufacture a set of eligible environments.
+
 `MintedRolloutLine` is `RolloutLine` plus a nominal brand (a phantom `unique symbol`, absent at runtime, so the JSON is unchanged).
 The distinction matters because `RolloutLine` is structural: any object literal of the right shape is one, so declaring `{reward: 0.95, realness_gated: true}` was enough to be accepted by every exporter that "only takes a line".
 Three producers mint the brand, and nothing else can:
@@ -49,7 +114,7 @@ Where each invariant lives:
 | unmeasured ≠ zero, at the record door | mint | `mintRolloutRows` throws a `ValidationError` naming the run and EVERY field the line is built from that the record does not carry: `costProvenance`, `tokenUsage` (+ `.input` / `.output`), `outcome` (+ `.raw`), `terminalOutcome`, `scenarioId`. The first, third and fifth were OPTIONAL through 0.125, so a ledger written then is full of records the TYPE calls complete. Absent provenance used to mint `cost.usd: 0` — the documented uncaptured sentinel published as a measurement — and an absent `terminalOutcome` or `outcome.raw` still minted a claim about a run nobody observed. The door refuses rather than normalising, because `is_completed` has no null to fall back to and only the producer knows whether `costUsd: 0` meant free or unbilled. `unmintableReasons(record)` reports the same list without throwing |
 | capture gap is a finding | mint and exporters | A missing trace, last-LLM-context projection, capped middle steps, or incomplete provider attempt sets `provenance.gap`. Known lossy projections also set `provenance.lossy_projection: true`, which training sinks exclude. A gap line may still be reconstructed by a separate explicit source lookup. The canonical ledger keeps them for audit. |
 | attempt identity stays intact | mint | `provenance.search` retains the exact search cell attempt. Optional `evidenceOf(runId)` accepts a run-bound receipt and preserves every provider attempt, native session ID, process ID, outcome, and missing reason in `provenance.attempts`. A mismatched run ID or absent requested receipt is refused. |
-| native reader loss is visible | readers | Claude JSONL reports malformed lines in `gaps` and unknown token fields as `null`. OpenCode SQLite rejects malformed message or part JSON and leaves unavailable session usage as `null`. The raw source remains authoritative. |
+| native reader loss is visible | readers | Claude JSONL reports malformed lines in `gaps`; Codex retains source hashes, malformed/torn records and capture gaps in `integrity`. Unknown token fields remain `null`. OpenCode SQLite rejects malformed message or part JSON and leaves unavailable session usage as `null`. The raw source remains authoritative. |
 | scrub | release pipeline | `scrubLines` applies the 9 deterministic rules to every string before publication |
 
 ## Runtime capture receipts
@@ -101,9 +166,10 @@ Validation preserves source order and rejects duplicate pairs or missing ordinal
 | the gate checks themselves | `src/rollout/gate-checks.ts` | `GATE_CHECK_IDS`, `GATE_CHECKS`, `GATE_POLICIES`, `gateErrors(subject, policy)` — the one list every entry point draws from. The subject is the LINE (`{outcome, steps}`), not the outcome alone: a per-step reward is training signal and lives outside `outcome`. `readReward` / `payloadIsPopulated` are the total readers every check narrows through, so a value the gate cannot classify is refused rather than read as clean |
 | ledger file API | `src/rollout/ledger.ts` | `writeRolloutLedger`, `appendRolloutLines`, `readRolloutLedger` |
 | minting from records | `src/rollout/mint.ts` | `mintRolloutRows(records, traceStore)`: RunRecord joined to trace via shared `runId`. `unmintableReasons(record)`: the same door's refusals, reported without throwing |
-| harness-store intake | `src/rollout/readers/` | `openOpencodeDb` + `readOpencodeSessionMessages` (opencode sqlite), `findClaudeTranscripts` + `readClaudeTranscript` (Claude Code project JSONL), `parseClaudeTranscript` (retained JSONL text) |
+| harness-store intake | `src/rollout/readers/` | `openOpencodeDb` + `readOpencodeSessionMessages` (opencode sqlite), `findClaudeTranscripts` + `readClaudeTranscript` (Claude Code project JSONL), `parseClaudeTranscript` (retained JSONL text), `readCodexRollout` / `parseCodexRollout` (resolved Codex native file / retained text) |
 | interchange | `src/rollout/interchange/harbor.ts` | `toHarborTrajectory` / `toHarborTrajectories` / `fromHarborTrajectory` / `relabelImportedSplit` (Harbor ATIF-v1.7); all root-exported as well as on the `/rollout` subpath |
 | exporters | `src/rollout/exporters.ts` | `toSftRows`, `toRewardRows`, `toVerifiersRolloutOutputs` (Prime Intellect), `toRftItems` (OpenAI RFT), `toJsonl` |
+| Tinker sink | `src/rollout/tinker.ts` | `toTinkerDatumRows`: captured tokens/logprobs to existing Tinker Datum, no training loop |
 | RL exporters | `src/rl/exporters.ts` | `toDpoRows`, `toGrpoRows`, `toSftRows`, `toPrmRows`; all training inputs are `MintedRolloutLine[]` or line-referenced artifacts with explicit line context |
 | release pipeline | `src/rollout/release/` | `scrubLines` (9 deterministic rules), `buildDatasetCard`, `buildHfDataset`, CLI `agent-eval rollout-release … [--push org/name]` |
 
@@ -122,7 +188,7 @@ Rule applied: where fields conflicted, RunRecord-derived semantics won; the ledg
 | `role` | ledger | enum extended with `agent` for solo eval runs (mint default) |
 | `task.split` | conflict | **RunRecord semantics win**: `search` is the trainable pool; `dev` and `holdout` follow `RunSplitTag`; `canary` is retained for release checks |
 | `task.seed`, `task.rep` | ledger | seed from `RunRecord.seed`; rep from the search cell for a search run, 0 for other minted runs |
-| `policy.*` | ledger | + `prompt_hash`, `config_hash`, `agent_profile_cell_id` from PR #410's RunRecord provenance |
+| `policy.*` | ledger | + `prompt_hash`, `config_hash`, `agent_profile_cell_id` from PR #410's RunRecord provenance; `license_class` (`open-weight-api`, `restricted`, `evaluation-only`, `human`; absent = inferred from model and harness by `licenseClassOf`) |
 | `messages` | ledger | canonical OpenAI chat-with-tools incl. `reasoning_content`; minted lines inline the final llm span's conversation |
 | `steps` | PR #410 | optional trace-span projections (llm/tool), absent on harness-store-derived lines |
 | `outcome.reward` | conflict | **merged**: `number \| null`; `null` means no verdict exists (a labeled gap, never 0 — interchange imports and unverdicted ledger lines carry it); minting requires an explicit RunRecord task score and rejects execution-only records instead of labeling them 0; realness-gated scores are forced to 0 |
@@ -138,6 +204,7 @@ Rule applied: where fields conflicted, RunRecord-derived semantics won; the ledg
 - SFT, reward rows, Verifiers, and RFT default to completed, non-truncated, error-free, ungated `search` runs with reward greater than `0`.
 - `minimumQualityExclusive` can raise the quality floor.
 - Held-out rows require `allowHeldOutTrainingData: true`.
+- Every license class trains by default; `allowLicenseClasses` re-cuts an export to the named classes.
 - SFT also requires a non-empty transcript.
 - Reward rows require a non-empty user prompt.
 - Verifiers requires both prompt and completion turns.
@@ -146,7 +213,7 @@ Rule applied: where fields conflicted, RunRecord-derived semantics won; the ledg
   Reward rows carry the same flag at `metadata.realness_gated`, and SFT rows carry it too even though it is always `false` there.
   Every one of those four shapes also carries `realness_screened` beside it (`RealnessLabels`): the verdict alone cannot say whether a screen ever ran, and a row stating one claim without the other is what let never-screened rewards read as clean.
 - Harbor ATIF export: no filter, because the format carries no reward at all — it is an interchange/audit sink, never a training-data door. A realness-gated line is exported with the gate stated in `notes` and in `extra.tangle.outcome.realness_gated`.
-- Release (`rollout-release`): trainable split only; proposer lines dropped unless `--include-proposers`; every string value scrubbed by the 9 deterministic rules (idempotent, so a second pass counts zero); `--push` requires `huggingface-cli` + `HF_TOKEN` and never prints the token.
+- Release (`rollout-release`): trainable split only; proposer lines dropped unless `--include-proposers`; any line with a secret or private detail (`privacyHit`: provider keys including `sk-tan` and `sk-ant-oat01`, env secrets, bearer tokens, private keys, high-entropy strings, emails, phones, postal addresses, `--denylist` terms) dropped whole and counted by rule in `scrub-report.json`; every string value scrubbed by the 9 deterministic rules (idempotent, so a second pass counts zero); `--push` requires `huggingface-cli` + `HF_TOKEN` and never prints the token.
   The per-format gate disposition is stated once as data in `src/rollout/release/gate-report.ts` (`sft: exclude`, everything else `zero-and-flag`), the build measures the rows it is about to write against it, and it writes nothing at all if any config would ship a gated row above reward 0, any positive number that reward was derived from, or a positive reward whose producer declared no screen ran on it.
   Those refusals are not listed in that file: it iterates `GATE_CHECK_IDS` under `GATE_POLICIES.assertGateReport`, so a check added anywhere in the package reaches the last door before a public dataset by default.
 - Property tests (`src/rollout/gate-properties.test.ts`) hold the whole exporter surface by GENERATION rather than by example: containment (no gated run's number reaches any exporter, through the minted door AND the raw object-literal door), order independence (leak 1 stated as a law — reordering the input changes no output), and idempotence (the gating transform and the Harbor round-trip). 1000 cases per property by default, `GATE_PROPERTY_RUNS` to raise it; the exporter registry there is a total map, so a new exporter with no probe does not compile.
@@ -217,3 +284,62 @@ It returns the same messages, tool calls/results, usage and source gaps as `read
 Set `includeSidechain: true` when reading a native subagent transcript.
 The caller retains the original bytes and verifies their artifact identity before parsing.
 This parser does not read CAS, store another copy, redact content or establish capture completeness.
+
+### Read retained Codex rollouts
+
+`readCodexRollout(path, options)` and `parseCodexRollout(raw, source, options)` from
+`@tangle-network/agent-eval/rollout` use the existing `harness-sessions` Codex
+reader and chat projection. `source` is that reader's `SessionInputInit`: retain
+the known native session ID and artifact label when reading an in-memory copy.
+Both paths preserve source hashes, parse gaps, truncation, parent identity and
+the SDK's inferred ending in `integrity` / `ending`. An inferred ending is not
+independent proof that a task succeeded or that the capture is complete.
+
+`usage` is the SDK's normalized session usage, whose cumulative counter wins
+over per-response sums. Its `input` excludes `cached_input_tokens`; separately
+reported cache counts and unknown channels pass through unchanged. No dollar
+price is invented. Codex's
+`turn_context` records a configured model, so `requestedModel` retains it while
+`model` stays null unless the source establishes a provider/session response.
+`modelSource` states that distinction.
+
+Resolve recent sessions from their live stores and older artifacts through the
+existing trace-archive session catalog and its `archive.py restore --path …
+--target …` path into owner-approved scratch on `/mnt/traces`. The caller owns
+that resolution and custody; these readers only accept a named file or text,
+never crawl an archive or create another store. Keep original artifact identity
+and review redaction before sharing. Feed the returned messages through the
+existing rollout mint/ledger APIs; the reader supplies no reward, split,
+training eligibility or permission to export Claude/Codex data for training.
+
+## Tinker RL Datums
+
+`toTinkerDatumRows` on `/rollout` consumes canonical minted lines and captured
+`llm` steps. It emits Tinker's existing text-only `Datum` shape with exactly
+`target_tokens`, `logprobs`, and `advantages`, shifted by one token and masked on
+prompt positions. Its attribution envelope keeps rollout/run/task/step identity;
+only `row.datum` belongs in the external SDK request.
+
+Tinker owns sampling, forward/backward and optimizer updates. The caller supplies
+an explicit advantage function and matching offline token decoder. Eval does not
+fetch credentials, install Tinker, start environments, re-tokenize text, invent
+sampling logprobs or train. Unknown reward is excluded; a completed honest zero
+or negative reward is retained. Gated, lossy, errored and incomplete rows are
+excluded. Search is eligible; held-out data requires the existing explicit
+opt-in. Dev/canary do not enter this training sink.
+
+Missing, empty or misaligned token data, multi-call steps, copied context without
+a captured token mask, duplicate rollout IDs and model mismatch refuse the batch.
+The existing scrub/share-safety owners check recorded text and decoded tokens.
+Content requiring changes is refused: redacting text while transmitting its
+original token IDs would leak the removed content and corrupt alignment.
+
+The [scripted Harbor recipe](../examples/tinker-rollouts/) runs only through the
+caller's admitted executor and existing Harbor adapter/verifier. Scripted actions
+have no sampled model logprobs and produce no training Datums. Twenty metadata
+candidates are not20 runnable environments; unavailable actual environments leave
+the requested dry run blocked. The recipe and loopback proof are not a claim of
+paid Tinker qualification or an executed20-environment campaign.
+
+See Tinker's official [loss layout](https://tinker-docs.thinkingmachines.ai/tinker/losses/)
+and [Datum API](https://tinker-docs.thinkingmachines.ai/tinker/api-reference/types/datum/).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.221.8",
+  "version": "0.222.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": {
@@ -228,34 +228,34 @@
   },
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^9.1.0",
-    "@hono/node-server": "^2.1.1",
+    "@hono/node-server": "^2.1.5",
     "@tangle-network/agent-core": "^0.13.2",
     "@tangle-network/agent-interface": "^5.7.1",
-    "@tangle-network/agent-trace-contract": "^2.0.0",
-    "@tangle-network/harness-sessions": ">=0.1.0 <0.2.0",
-    "hono": "^4.13.9",
+    "@tangle-network/agent-trace-contract": "^2.1.0",
+    "@tangle-network/harness-sessions": "^0.2.1",
+    "hono": "^4.13.14",
     "linear-sum-assignment": "1.0.9",
-    "re2js": "2.8.6",
-    "smol-toml": "1.9.0",
-    "zod": "4.6.6"
+    "re2js": "2.9.0",
+    "smol-toml": "1.9.1",
+    "zod": "4.6.7"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
-    "@biomejs/biome": "^2.5.14",
-    "@types/node": "^26.6.2",
+    "@biomejs/biome": "^2.6.3",
+    "@types/node": "^26.6.5",
     "ajv": "8.20.0",
     "esbuild": "^0.28.2",
     "fast-check": "^4.10.2",
     "husky": "^9.1.7",
     "lib-r-math.js": "^3.0.2",
-    "lint-staged": "^17.5.1",
-    "openapi3-ts": "^4.6.1",
-    "oxc-parser": "^0.151.0",
-    "publint": "^0.3.24",
-    "tsdown": "^0.23.0",
+    "lint-staged": "^17.6.0",
+    "openapi3-ts": "^4.6.2",
+    "oxc-parser": "^0.155.0",
+    "publint": "^0.3.25",
+    "tsdown": "^0.23.2",
     "tsx": "^4.23.15",
-    "typescript": "^7.0.2",
-    "vitest": "^5.0.1"
+    "typescript": "6.0.3",
+    "vitest": "^5.0.5"
   },
   "engines": {
     "node": ">=20.19.0"
@@ -269,5 +269,5 @@
     ]
   },
   "license": "MIT",
-  "packageManager": "pnpm@12.6.0"
+  "packageManager": "pnpm@12.15.0"
 }

package/dist/adversarial-smnADNFS.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adversarial-smnADNFS.d.ts","names":[],"sources":["../src/rl/adversarial.ts"],"mappings":";;;;;;;;;;UAUiB,oBAAoB;EACnC;;;;;EAKA,OAAO,QAAQ,GAAG,oBAAoB,QAAQ,OAAO"}

package/dist/agent-profile-CNmwfaqq.d.ts.map

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"agent-profile-cell-BcpFbNd5.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;;iBAWT,sBACpB,OAAO,wBACN,QAAQ;;;;;;iBAiBW,uBAAuB,MAAM,mBAAmB;iBAMtD,yBAAyB,iBAAiB;iBAkC1C,oBAAoB;EAClC;EACA,eAAe;;iBAOD,4BACd;EAAY;EAAe,eAAe;GAC1C,kBAAkB,MAAM,YAAY;;;;;cA0NzB;;;;WAIX;;KAGU,2BAA2B,kCAAkC;;;;iBAKzD,mBAAmB,iBAAiB;;KAYxC,4BAA4B;EAAiB;EAAc"}

package/dist/analyze-runs-DfX6dHP0.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze-runs-DfX6dHP0.d.ts","names":[],"sources":["../src/contract/insight-report.ts","../src/contract/execution-insight.ts","../src/contract/analyze-runs.ts"],"mappings":";;;;;;;UAqCiB;;EAEf;;;;EAKA,WAAW;;EAGX,WAAW;;;EAIX,cAAc,eAAe;;EAG7B;IACE,MAAM;IACN,QAAQ;;;;;IAKR,aAAa;;;;;IAKb;MAAa;MAAe;;;;;;EAM9B,QAAQ,eAAe;;;;EAKvB,aAAa;;;;EAKb,OAAO;;;EAIP,kBAAkB;;;EAIlB,gBAAgB;;;;;EAMhB,qBAAqB;;;;;EAMrB,SAAS;;;;;;EAOT,wBAAwB;;;;EAKxB,iBAAiB;;;EAIjB,iBAAiB;;UAGF;EACf;IAAY;IAAW;;EACvB;IAAa;IAAW;;;;EAGxB;IAAc;IAAW;;EACzB;IAAc;;EACd;;UAGe;;EAEf,YAAY;;EAEZ,SAAS;;;EAGT,YAAY;;;EAGZ;IACE;IACA,YAAY;IACZ,SAAS;IACT;;;EAGF,QAAQ;IAAQ;IAAe;;;;;EAI/B;IACE;IACA;IACA;;;;;EAKF;IACE;;;IAGA;;IAEA;;IAEA;;IAEA;;IAEA;;;;;IAKA,mBAAmB,OAAO,oBAAoB;;;;EAIhD;IACE;IACA;IACA;IACA;IACA;;;UAIa;;EAEf;;EAEA;;EAEA;;UAGe;EACf,OAAO;EACP,QAAQ;EACR,WAAW;EACX,QAAQ;EACR,YAAY;EACZ;IACE;IACA;IACA;IACA;IACA;;;;UAOa;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,WAAW;;;;;EAKX,WAAW;IAAQ;IAAe;;;UAGnB;;EAEf;;EAEA;;;EAGA,cAAc;;;EAGd;;;EAGA;;;EAGA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;EAET,mBAAmB;IACjB;IACA,SAAS;MAAQ;MAAe;;IAChC;;;UAIa;EACf;EACA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;EAWA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf,UAAU;IACR;IACA;;IAEA;;IAEA;;IAEA;;EAEF;;;;;UAMe;;EAEf,cAAc;;EAEd;;EAEA;;UAGe;;EAEf;;;EAGA;EACA,UAAU;IAAQ;IAAe;IAAgB;;;UAGlC;;;EAGf;;EAEA;;EAEA;;EAEA;;EAEA;IACE;IACA;IACA;;;UAIa;;;EAGf;EACA,MAAM;IACJ;IACA;IACA;;;;EAIF;;UAGQ;;EAER;;EAEA;;;;EAIA;;EAEA;EACA;;KAGU,eACP;EACC;;EAEA;;EAEA;;EAEA;;EAEA;MAED;EACC;;EAEA;EACA;EACA;EACA;;UAGW;;EAEf;EACA;;EAEA;;;;EAIA,SAAS,eAAe;;;EAGxB;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;;;UCzbe;EACf,MAAM;EACN;;UAGe;EACf,WAAW;EACX,gBAAgB;;;iBAIF,mBAAmB,MAAM,4BAA4B;;;UC4BpD;;EAEf,MAAM;;;EAGN;;;;;EAKA;EACA;;;EAGA,8BAA8B;;;EAG9B,kBAAkB;;;EAGlB,UAAU;;;;EAIV;IACE;IACA,cAAc;;;;;EAKhB,cAAc;IAAQ;IAAe;IAAe;;;EAEpD;;;;EAIA;;;;;;;;;EASA,eAAe;;;EAGf;;iBAGoB,YAAY,MAAM,qBAAqB,QAAQ"}

package/dist/attribute-vocabulary-CcXqHODT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attribute-vocabulary-CcXqHODT.d.ts","names":[],"sources":["../src/trace/attribute-vocabulary.ts"],"mappings":";;;;;;;;cAqBa;cACA;cACA;cACA;cACA;cACA;cACA;;cAEA;cACA;cACA;cACA;cACA;cACA;cACA;cAEA;cACA;cACA;cACA;;cAEA;cACA;cACA;;;;;;cAOA;;cAGA;cAEA;;iBAGG,SAAS;;iBAUT,gBACd,YAAY,yBACZ;;iBAUc,mBAAmB;EACjC;EACA;EACA;;UAMe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;iBAIc,2BACd,YAAY,yBACZ,MAAM"}