@tangle-network/agent-eval 0.128.2 → 0.130.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/wire/schemas.ts","../../src/wire/handlers.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/specification-extension.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/node_modules/openapi3-ts/dist/model/oas-common.d.ts","../../node_modules/.pnpm/openapi3-ts@4.6.0/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,81 +1,2 @@
-import {
-  BUILTIN_RUBRICS,
-  ErrorResponseSchema,
-  FailureModeSchema,
-  FeedbackAttemptSchema,
-  FeedbackIngestResponseSchema,
-  FeedbackLabelSchema,
-  FeedbackTrajectorySchema,
-  HealthResponseSchema,
-  JudgeRequestSchema,
-  JudgeResultSchema,
-  ListRubricsResponseSchema,
-  RubricDimensionSchema,
-  RubricInfoSchema,
-  RubricSchema,
-  TraceEventSchema,
-  TracesIngestRequestSchema,
-  TracesIngestResponseSchema,
-  VersionResponseSchema,
-  WIRE_VERSION,
-  WireError,
-  buildOpenApi,
-  createApp,
-  dispatchRpc,
-  getBuiltinRubric,
-  handleFeedbackIngest,
-  handleJudge,
-  handleListRubrics,
-  handleTracesIngest,
-  handleVersion,
-  hashRubric,
-  listBuiltinRubrics,
-  runRpcBatch,
-  runRpcOnce,
-  startServer,
-  startServerAsync
-} from "../chunk-YJBNWCAA.js";
-import "../chunk-PBE2LOSS.js";
-import "../chunk-WS3NZZQQ.js";
-import "../chunk-VI2UW6B6.js";
-import "../chunk-PC4UYEBM.js";
-import "../chunk-ONWEPEDO.js";
-import "../chunk-PZ5AY32C.js";
-export {
-  BUILTIN_RUBRICS,
-  ErrorResponseSchema,
-  FailureModeSchema,
-  FeedbackAttemptSchema,
-  FeedbackIngestResponseSchema,
-  FeedbackLabelSchema,
-  FeedbackTrajectorySchema,
-  HealthResponseSchema,
-  JudgeRequestSchema,
-  JudgeResultSchema,
-  ListRubricsResponseSchema,
-  RubricDimensionSchema,
-  RubricInfoSchema,
-  RubricSchema,
-  TraceEventSchema,
-  TracesIngestRequestSchema,
-  TracesIngestResponseSchema,
-  VersionResponseSchema,
-  WIRE_VERSION,
-  WireError,
-  buildOpenApi,
-  createApp,
-  dispatchRpc,
-  getBuiltinRubric,
-  handleFeedbackIngest,
-  handleJudge,
-  handleListRubrics,
-  handleTracesIngest,
-  handleVersion,
-  hashRubric,
-  listBuiltinRubrics,
-  runRpcBatch,
-  runRpcOnce,
-  startServer,
-  startServerAsync
-};
-//# sourceMappingURL=index.js.map
+import { A as TraceEventSchema, C as HealthResponseSchema, D as RubricDimensionSchema, E as ListRubricsResponseSchema, F as hashRubric, M as TracesIngestResponseSchema, N as VersionResponseSchema, O as RubricInfoSchema, P as WIRE_VERSION, S as FeedbackTrajectorySchema, T as JudgeResultSchema, _ as ErrorResponseSchema, a as runRpcBatch, b as FeedbackIngestResponseSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as listBuiltinRubrics, h as getBuiltinRubric, i as dispatchRpc, j as TracesIngestRequestSchema, k as RubricSchema, l as handleFeedbackIngest, m as BUILTIN_RUBRICS, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FailureModeSchema, w as JudgeRequestSchema, x as FeedbackLabelSchema, y as FeedbackAttemptSchema } from "../server-m5D9cvnG.js";
+export { BUILTIN_RUBRICS, ErrorResponseSchema, FailureModeSchema, FeedbackAttemptSchema, FeedbackIngestResponseSchema, FeedbackLabelSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RubricDimensionSchema, RubricInfoSchema, 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/feature-guide.md

@@ -151,7 +151,7 @@ Store as `FeedbackTrajectory`, then derive:
 
 | Area | Key exports | Best for | Notes |
 | --- | --- | --- | --- |
-| Judging | `createCustomJudge`, semantic judges, anti-slop, wire rubrics | Content, voice, semantic quality | Pair with objective checks when possible. |
+| Judging | `llmJudge`, semantic judges, anti-slop, wire rubrics | Content, voice, semantic quality | Pair with objective checks when possible. |
 | Verification | `MultiLayerVerifier`, `JudgeRunner`, sandbox harness | Code and multi-step gates | Do not let semantic judges override failed builds. |
 | Control | `runAgentControlLoop`, `objectiveEval`, `subjectiveEval` | Long-running agent tasks | Supports budgets, cost, stop policies, trace spans. |
 | Propose/review | `runProposeReview`, `runProposeReviewAsControlLoop` | Iterative artifact repair | Good for code, docs, plans, briefs. |

package/docs/rollout.md

@@ -4,15 +4,63 @@
 One JSONL line per agent invocation, with the full transcript inline, a single scalar reward, and fail-closed split labels.
 No other package may write rollout rows; domain repos (e.g. the bench swe-arena backfill) construct lines from their own joins and serialize them exclusively through this module's `writeRolloutLedger` / `appendRolloutLines`.
 
+## The hourglass: sources → waist → sinks
+
+Many producers, one waist, many consumers.
+Every invariant is enforced once, at the waist, so no sink can be reached by a path that skips it.
+
+```
+SOURCES                      WAIST                         SINKS
+RunRecord × trace   ─┐                          ┌─→ SFT chat JSONL        (toSftRows)
+opencode sqlite     ─┤                          ├─→ reward rows           (toRewardRows)
+Claude Code 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)
+```
+
+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.
+
+`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:
+
+| producer | how the invariant is established |
+| --- | --- |
+| `mintRolloutRows` | applies the gate (`trainingReward`) and validates the line it built |
+| `readRolloutLedger` | validates every line off disk, then normalizes `realness_gated` to an explicit boolean |
+| `assertMinted` / `assertMintedLines` | the explicit escape hatch for a hand-built or reconstructed line — grep it to enumerate every such site |
+
+Readers, analysis, the ledger writer and the Harbor interchange keep taking the plain `RolloutLine`.
+
+Where each invariant lives:
+
+| invariant | enforced at | mechanism |
+| --- | --- | --- |
+| realness gate (anti-Goodhart) | `validateRolloutLine` (runtime) + the `MintedRolloutLine` brand (compile time) | `reward > 0` together with `realness_gated: true` is an INVALID line: it cannot be written to a ledger, read from one, minted, or handed to an exporter. Mint forces the reward to 0; `toSftRows` additionally refuses gated lines |
+| every guard applies every check | `src/rollout/gate-checks.ts` | `GATE_CHECKS` is the one list of gate checks, and each of the four entry points (`validateRolloutLine`, `assertMinted`, `assertRewardGate`, `assertGateReport`) declares a TOTAL `GatePolicy` over it. Adding a check makes every policy a type error until it is wired, an entry point that skips one must write the reason in `omittedBecause(...)`, and each check's `tripwire` is fed to every entry point that claims to enforce it. Four rounds of leaks were all the same defect — a guard composing its checks by hand |
+| never-screened ≠ screened-clean | `assertMinted` + `RealnessLabels` on every emitted row | `realness_gated: false` is the screen's VERDICT, so a producer with no screen was claiming "we looked and nothing fired". `realness_screened` separates the claims (`true` ran / `false` declared absent / `null` not stated) and travels beside `realness_gated` on every exported row shape. `assertMinted` refuses a positive reward carrying `realness_screened: false`; supervision-journal rows stay writable and readable, only promotion into training is closed |
+| a line-less artifact names ONE invocation | `admitUngatedByInvocation` | `PreferenceTriple` / `PrmTrainingTriple` / `StepReward` carry run ids, and many invocations share a `run_id`. References resolve against `rollout_id` first and fall back to `run_id` only when that run holds exactly one invocation; an ambiguous reference DROPS the item and announces the count, a missing one throws. Keying on `run_id` alone was last-wins, which made the gate depend on array order |
+| no hand-rolled score derivation | `src/rollout/score-derivation-guard.ts`, asserted by `reward-invariant.test.ts` | an AST walk over `src/**` flags every READ of `outcome.holdoutScore` / `outcome.searchScore` outside a counted allowlist. It replaced a line regex that seven ordinary reformattings walked past |
+| split fail-closed | `isTrainableSplit` at every training sink | only `search` ships by default; held-out data requires explicit consent, while `dev` and `canary` never train |
+| unlabeled ≠ zero | schema | `outcome.reward: null` is a labeled gap; reward-row and SFT exporters drop null, they never coerce it to 0 |
+| capture gap is a finding | mint | records without spans become `messages: []` lines with `provenance.gap` AND are listed in `missingTraces` |
+| scrub | release pipeline | `scrubLines` applies the 9 deterministic rules to every string before publication |
+
 ## Module map
 
 | concern | file | entry points |
 | --- | --- | --- |
 | schema + validation | `src/rollout/schema.ts` | `RolloutLine`, `validateRolloutLine`, `assertRolloutLine`, `isTrainableSplit` |
+| 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` |
 | harness-store intake | `src/rollout/readers/` | `openOpencodeDb` + `readOpencodeSessionMessages` (opencode sqlite), `findClaudeTranscripts` + `readClaudeTranscript` (Claude Code project jsonl) |
+| 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` |
+| 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]` |
 
 ## Schema decision table
@@ -33,8 +81,8 @@ Rule applied: where fields conflicted, RunRecord-derived semantics won; the ledg
 | `policy.*` | ledger | + `prompt_hash`, `config_hash`, `agent_profile_cell_id` from PR #410's RunRecord provenance |
 | `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); minting requires an explicit RunRecord task score and rejects execution-only records instead of labeling them 0; realness-gated scores are forced to 0 |
-| `outcome.realness_gated` | PR #410 | required boolean; the anti-Goodhart decision travels with the row and every training export refuses gated 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 |
+| `outcome.realness_gated` | PR #410 | required boolean; the anti-Goodhart gate travels into the data, the validator refuses it beside a positive reward, and SFT export refuses gated lines outright. `outcome.realness_screened` rides beside it (optional tri-state) so a screened-clean reward is distinguishable from a never-screened one |
 | `outcome.reward_source` / `verdict` / `metrics` | ledger | unchanged; mint fills `metrics` from `RunRecord.outcome.raw` |
 | `outcome.is_completed` / `is_truncated` / `error` | conflict | mint derives terminal fields from the required `RunRecord.terminalOutcome`; producers use the explicit `unknown` value when terminal evidence is unavailable |
 | `cost.*` | ledger | superset of PR #410's costUsd/totalTokens; `cost.usd` is `null` when `costProvenance.kind === 'uncaptured'` (never a fake 0) |
@@ -50,4 +98,70 @@ Rule applied: where fields conflicted, RunRecord-derived semantics won; the ledg
 - Reward rows require a non-empty user prompt.
 - Verifiers requires both prompt and completion turns.
 - RFT requires prompt turns before the first assistant turn.
+- Verifiers / RFT additionally accept `gatedLines: 'zero-and-flag'` — the dataset release's declared disposition — which keeps realness-gated lines and honest failures in the output at their non-positive reward with the gate stated on the row (`info.realness_gated`, `reference.realness_gated`): the reward in those formats is a signed learning signal, and dropping the gamed population would bias the negatives toward honest failures while hiding the gaming from the buyer. The split policy is NOT relaxed by the disposition.
+  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.
+  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.
+  The dataset card does not assert anything about the gate — it renders the measured counts (`BuildSummary.gate`) and throws when they disagree with the lines it describes, so a README cannot drift from the data files beside it.
+
+## Harbor ATIF-v1.7 interchange
+
+[Agent Trajectory Interchange Format](https://www.harborframework.com/docs/agents/trajectory-format) (normative RFC: `harbor-framework/harbor` `rfcs/0001-trajectory-format.md`) is the portability format for agent trajectories.
+It is both a source and a sink of the hourglass, and it sits below the waist in both directions: `toHarborTrajectory` reads `RolloutLine[]`, `fromHarborTrajectory` writes `RolloutLine[]`.
+
+**ATIF models no reward, no judge verdict, and no task/split coordinates.**
+Everything else follows from that one fact.
+
+| our field | ATIF | note |
+| --- | --- | --- |
+| `rollout_id` | `trajectory_id` | required by the spec on every embedded subagent |
+| `parent_rollout_id` | tree placement in `subagent_trajectories` | our flat edge becomes ATIF's embedding; import flattens it back |
+| `run_id` | `session_id` | ATIF's session is RUN-scoped, and `run_id` is our run-scoped coordinate; every node of an episode carries it, and two roots of one run therefore group as one session |
+| `policy.harness` / `harness_version` | `agent.name` / `agent.version` | ATIF requires both as strings; a null becomes `unknown` / `0.0.0` and is restored exactly from escrow, never guessed back |
+| `policy.model` | `agent.model_name` + `step.model_name` | |
+| `tool_defs` | `agent.tool_definitions` | byte-identical OpenAI function schema, zero transform |
+| `messages[]` | `steps[]` | coalescing fold: ATIF has no `tool` source, so a tool result becomes an `observation.results[]` entry on the step that DECLARED its `tool_call_id` (RFC MUST rule 2), never on whichever step happened to precede it |
+| `ChatMessage.is_copied_context` | `step.is_copied_context` | RFC rule 7: a turn copied in from another trajectory. Native field both ways, and `toSftRows` drops those turns |
+| `ChatToolCall.function.arguments` (string) | `tool_calls[].arguments` (object) | the raw string is kept in the call's `extra` so a malformed argument blob round-trips verbatim instead of being normalized |
+| `cost.usd` / `tokens_in` / `tokens_out` / `cache_read` | `final_metrics.total_*` | omitted, never 0, when not captured |
+| `cost.tokens_reasoning` / `cache_write` / `wall_s` / `llm_call_count` | `final_metrics.extra.*` | no ATIF field; `reasoning_tokens` is the key the RFC's own example uses |
+| `steps[]` (span projections) | `extra.tangle.spans` + `step.metrics` / `step.llm_call_count` | the whole span stays escrowed (ATIF steps are conversation turns, and folding spans in would double-count the run), but the four RL fields ALSO ride ATIF's native per-step channel — a field only our own reader can see is not an interchange field. Escrow wins on import; the native channel is what a foreign document is read through |
+| `task.*`, `policy.*`, `artifacts.*`, `provenance.*`, `role`, ids | `extra.tangle.*` | namespaced escrow; a foreign reader ignores it, our round-trip is exact |
+| `outcome.realness_gated` | `extra.tangle.outcome.realness_gated` + `notes` | stated in prose too, because a consumer that ignores `extra` would otherwise see a gamed trajectory with nothing marking it |
+| `outcome.reward` / `reward_source` / `verdict` | — **dropped** | not escrowed either: a third party must not be able to mistake an agent-eval judge score for something ATIF sanctioned |
+
+Import consequences, all deliberate:
+
+- Every imported line is **unlabeled**: `reward`, `reward_source` and `verdict` are `null` and `provenance.gap` says `imported from Harbor ATIF; no verdict`. That is the existing "null reward is a labeled gap, never 0" rule — an imported trajectory becomes a training example only once a judge scores it.
+- **Every** imported trajectory lands on **`holdout`**, whatever the document says. `extra.tangle` is namespaced, not authenticated: a hand-written or third-party file can set `task.split: 'search'` as easily as our exporter can, and honouring it made "this file says so" enough to reach a training export. Promoting an import to a trainable split is a separate, greppable act — `relabelImportedSplit(lines, split)` — so `grep relabelImportedSplit` enumerates every place foreign data was declared trainable. The claim itself is not destroyed; it stays readable in the source document.
+- Round-tripping is **idempotent**: `provenance.gap` is composed as a de-duplicated ordered set (it used to accrete one copy of the import note per pass), and every imported `ChatMessage` is emitted with keys in the canonical schema order, so a ledger hashed on serialized bytes sees no diff on further passes. The first import may re-order a producer's keys — that is the canonicalization.
+- We do not synthesize `observation.subagent_trajectory_ref` on export. Our ledger records which *invocation* spawned a worker, not which *step* did; attaching the ref to a guessed step would fabricate a causal claim. The edge lives in the child's escrowed `parent_rollout_id`.
+- Multimodal `ContentPart[]` flattens to text (our chat content is `string | null`); image parts become a `[image <media_type> <path>]` marker rather than being dropped silently.
+- A cycle in `parent_rollout_id` or `subagent_trajectories` throws instead of emitting zero documents or recursing forever.
+
+### Fields adopted from ATIF
+
+Four optional fields were added to our schema because ATIF carries real RL signal we were not capturing.
+All are optional and never back-filled, so every ledger written before they existed still validates: absent means "not captured", which is a different claim from `0` or `[]`.
+
+| field | on | why |
+| --- | --- | --- |
+| `logprobs` | `RolloutStep` | per-completion-token log probabilities — required for off-policy correction when the rollout came from a different policy than the one being trained |
+| `completion_token_ids` | `RolloutStep` | exact completion tokenization; removes the ambiguity of re-tokenizing text at train time |
+| `prompt_token_ids` | `RolloutStep` | exact prompt tokenization |
+| `llm_call_count` | `RolloutStep` and `RolloutCostBlock` | inferences per span and per invocation; `0` means deterministic dispatch with no model call |
+| `is_copied_context` | `ChatMessage` | RFC 0001 rule 7 makes excluding these turns from SFT a MUST — they were authored by another agent, so training on them credits this run for another's work |
+
+The per-step four (`logprobs`, `completion_token_ids`, `prompt_token_ids`, `llm_call_count`) are wired through the interchange in BOTH directions on ATIF's own `step.metrics` / `step.llm_call_count`, not only in our escrow.
+Export matches the k-th `llm` span to the k-th agent step; import prefers the escrow when it exists and falls back to the native channel, which is the only thing a Harbor-native producer writes.
+A step carrying none of the four produces no span — absent stays absent.
+
+### Why there is no Letta converter
+
+Letta's trajectory-v1 is a strict subset of what we need from ATIF for this purpose: no per-step or aggregate cost, no multi-agent/subagent structure, and no token-id or logprob channel.
+A Letta sink would therefore carry strictly less than the ATIF one while adding a second format to keep correct against schema drift.
+Do not add one without a concrete consumer that reads Letta and cannot read ATIF.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.128.2",
+  "version": "0.130.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": {
@@ -94,6 +94,11 @@
       "import": "./dist/campaign/index.js",
       "default": "./dist/campaign/index.js"
     },
+    "./ledger-core": {
+      "types": "./dist/ledger-core/index.d.ts",
+      "import": "./dist/ledger-core/index.js",
+      "default": "./dist/ledger-core/index.js"
+    },
     "./storyboard": {
       "types": "./dist/storyboard/index.d.ts",
       "import": "./dist/storyboard/index.js",
@@ -145,8 +150,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup && node scripts/build-declarations.mjs && pnpm openapi",
-    "dev": "tsup --watch",
+    "build": "tsdown && pnpm openapi",
+    "dev": "tsdown --watch",
     "prepare": "husky",
     "prepublishOnly": "pnpm build",
     "test": "vitest run",
@@ -157,27 +162,30 @@
     "format": "biome format --write src",
     "check:skill": "node scripts/check-skill.mjs",
     "openapi": "node dist/cli.js openapi --out dist/openapi.json",
-    "verify:package": "pnpm run check:skill && node scripts/verify-package-exports.mjs"
+    "verify:package": "pnpm run check:skill && publint && attw --pack --profile esm-only . && node scripts/verify-package-exports.mjs"
   },
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^9.1.0",
     "@ax-llm/ax": "^23.0.5",
-    "@hono/node-server": "^2.0.11",
-    "@tangle-network/agent-core": "0.4.21",
-    "@tangle-network/agent-interface": "0.33.0",
-    "@tangle-network/tcloud": "^0.4.14",
+    "@hono/node-server": "^2.0.12",
+    "@tangle-network/agent-core": "0.4.24",
+    "@tangle-network/agent-interface": "0.35.0",
     "hono": "^4.12.32",
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
     "@biomejs/biome": "^2.5.5",
     "@types/node": "^26.1.1",
     "esbuild": "^0.28.1",
+    "fast-check": "^4.9.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.2.0",
     "openapi3-ts": "^4.6.0",
-    "tsup": "^8.0.0",
-    "typescript": "^6.0.3",
+    "oxc-parser": "^0.141.0",
+    "publint": "^0.3.22",
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.10",
     "yaml": "2.9.0"
   },

package/dist/benchmarks/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/campaign/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}