@tangle-network/agent-eval 0.135.4 → 0.137.0

package/dist/types-CTvKfr5F.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CTvKfr5F.d.ts","names":[],"sources":["../src/trace/raw-provider-sink.ts","../src/llm-client.ts","../src/analyst/chat-client.ts","../src/types.ts"],"mappings":"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;;;iBAO9C,iBAAiB,MAAM,uBAAuB;;;UCjH7C;EACf;EACA;EACA;EACA;EACA;EACA,OAAO;EACP,gBAAgB;EAChB;;UAGe;EACf;EACA;EACA;EACA;;UAKe;EACf;EAQA;EACA;EACA;EACA;;UAKe;EACf;EACA;EACA,QAAQ;;UAGO;EACf;EACA;EACA,YAAY;;UAGG;EACf;EACA;EACA;EACA;EACA;;UAKe;EACf;EACA;EACA,OAAO;EACP,iBAAiB;EACjB,aAAa;EACb;EACA;EACA;EACA,WAAW;;EAEX,OAAO;;UAGQ;EACf;EACA;EACA;EACA;EACA;IAAmB;IAAc;;EACjC;EACA;;UAGe;EACf,OAAO;EACP;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;IAAc;IAAc;;EAC5B;IAAmB;IAAc,QAAQ;;EACzC;IAAc;IAAkB;;EAChC;;UAKe;EACf;EACA;EACA;EACA;EACA,SAAS;EACT,OAAO;EACP;IACE;IACA,WAAW;MAAiB;MAAa;MAAgB;;IACzD,aAAa;MAAiB;MAAa;;IAC3C;MAAW;MAAkB;MAAe;;IAC5C;MAAa;MAAkB;MAAe;;;;UAMjC;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;GACC;;UAGc;EACf;EACA,QAAQ;;EAER;;UAKe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;IACE;MACE;MACA;MACA;;;EAGJ,OAAO;EACP,gBAAgB;;UAKD;EACf;EACA,QAAQ,OAAO;EACf,YAAY,OAAO;;UAGJ;EACf;EACA;;;;;;;;;;KAWU;UAEK;EACf;EACA;EACA;EACA,oBAAoB;EACpB,mBAAmB;EACnB;EACA;;EAEA,QAAQ;;;;;;;EAOR;;;;;;;EAOA;;;;;;EAMA;;UAGe;EACf;EACA;EACA;IAAa;IAAiB;IAAkB;;EAChD;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;IAAa;IAAiB;IAAkB;;EAChD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf;;EAEA;;EAEA;;;;;;EAMA;EACA;EACA,SAAS;EACT,YAAY;EACZ;EACA;EACA;;UAKe;EACf,WAAW;EACX,QAAQ;EACR;EACA;EACA;EACA;EACA;EACA;;EAEA,aAAa;;UAGE;EACf,UAAU;EACV,OAAO;EACP,WAAW;;EAEX,aAAa;EACb;EACA,WAAW;EACX,SAAS;;KAGC,WAAW,MAAM,YAAY,OAAO,eAAe,QAAQ;UAItD;EACf;EACA;EACA;EACA;EACA,QAAQ;;UAGO;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA"}

package/dist/{index-C61Wi7yg.d.ts → types-Dea6tiVI.d.ts}

@@ -1,4 +1,4 @@
-import { b as RolloutSplit, h as RolloutLine } from "./schema-Cef2cFmb.js";
+import { h as RolloutLine } from "./schema-Cef2cFmb.js";
 //#region src/supervisor-run/types.d.ts
 /** A metric that could not be computed, with the reason its artifact was missing. */
 interface Unavailable {
@@ -10,8 +10,19 @@ declare function unavailable(reason: string): Unavailable;
 declare function isUnavailable(v: unknown): v is Unavailable;
 /** Render a measured scalar for the markdown/headline: `0` and `unavailable` stay distinct. */
 declare function showMeasured(v: Measured<number | string | boolean | null>): string;
-/** One worker's logs, as read. `null` = the artifact did not exist. */
+/** The two invocation roles a recursive supervision tree can contain. */
+type SupervisorRunNodeRole = 'supervisor' | 'worker';
+/**
+ * One worker's logs, as read. `null` means the artifact did not exist; `''`
+ * means the artifact was captured and contained no rows.
+ */
 interface WorkerLogSource {
+  /**
+   * Stable journal node id. Readers should set this whenever their source has
+   * one; `label` remains the compatibility join for older stores.
+   */
+  readonly workerId?: string;
+  /** Human-readable task label. It is not required to be unique. */
   readonly label: string;
   /** Worker event stream — started / progress / finished / message events (JSONL). */
   readonly events: string | null;
@@ -41,6 +52,10 @@ interface WorkerLogSource {
  * `null` on a field means the source DOES carry that fact.
  */
 interface SourceLimits {
+  /** Reason manager input/output token totals are unavailable (null = recorded). */
+  readonly managerTokens: string | null;
+  /** Reason worker input/output token totals are unavailable (null = recorded). */
+  readonly workerTokens: string | null;
   /** Reason inference spend has no price in this store (null = the store prices it). */
   readonly spendUsd: string | null;
   /** Reason workers carry no pass/fail verdict (null = verdicts are recorded). */
@@ -67,7 +82,11 @@ interface SupervisorRunSources {
   readonly arm: string | null;
   /** Identity of the supervision-tree store this was read from; null = none found. */
   readonly supRunDir: string | null;
-  /** Supervision journal — spawned / settled / cancelled / metered events (JSONL). */
+  /**
+   * Supervision journal — spawned / settled / cancelled / metered events (JSONL).
+   * Recursive readers put `role: 'supervisor' | 'worker'` on spawned rows;
+   * settled `verdict` may be a legacy string or `{ valid, score, ... }`.
+   */
   readonly journal: string | null;
   /** Per-brain-call tap (JSONL): finish_reason, completion tokens, requested max tokens. */
   readonly brainLog: string | null;
@@ -134,6 +153,8 @@ interface SupervisorRunReader {
 declare const SUPERVISOR_RUN_SCHEMA = "tangle.supervisor-run@1";
 declare const SUPERVISOR_RUN_ROLLUP_SCHEMA = "tangle.supervisor-run-rollup@1";
 interface SteerBreakdown {
+  /** Stable journal node id when the reader retained one. */
+  readonly workerId: string | null;
   readonly worker: string;
   /** Steer requests durably queued to this worker's inbox. */
   readonly queued: number;
@@ -158,9 +179,9 @@ interface OrchestrationMetrics {
   readonly waves: Measured<number>;
   readonly waveSizes: Measured<readonly number[]>;
   readonly maxConcurrency: Measured<number>;
-  /** Worker spawns issued after the first settlement — the retry/respawn tail. */
+  /** Direct-child spawns issued after that parent's first direct-child settlement. */
   readonly respawns: Measured<number>;
-  /** Labels spawned more than once (a literal retry of the same subtask). */
+  /** Labels spawned more than once by the same parent. */
   readonly repeatedLabels: Measured<readonly string[]>;
   /** Longest parent chain below the root, in worker hops. */
   readonly delegationDepth: Measured<number>;
@@ -181,9 +202,9 @@ interface DecisionMetrics {
   readonly rejected: Measured<number>;
   /** Worker verified green but delivered no patch bytes — output with nothing to accept. */
   readonly emptyPass: Measured<number>;
-  /** Settlements the brain observed before issuing its next spawn (evidence→respawn). */
+  /** Direct-child settlements a parent observed before issuing its next direct-child spawn. */
   readonly observeThenRespawn: Measured<number>;
-  /** Respawns with no settled evidence in front of them. */
+  /** Parent-local respawns with no direct-child settlement in front of them. */
   readonly respawnWithoutEvidence: Measured<number>;
   /** Steer + question traffic on the live down/up legs — the only "review while running" signal. */
   readonly reviewActions: Measured<number>;
@@ -203,7 +224,11 @@ interface RoleSpend {
   readonly source: string;
 }
 interface PerWorkerRow {
+  /** Stable journal node id when the reader retained one. */
+  readonly workerId: string | null;
   readonly worker: string;
+  /** Explicit journal role after the worker source was joined to its spawn. */
+  readonly role: SupervisorRunNodeRole | null;
   readonly wallMs: number | null;
   /** `null` = this store does not attribute tokens per worker (NOT "zero tokens"). */
   readonly tokensIn: number | null;
@@ -211,6 +236,8 @@ interface PerWorkerRow {
   readonly usd: number | null;
   readonly patchBytes: number | null;
   readonly passed: boolean | null;
+  /** Numeric verdict score exactly as recorded; null means no score was recorded. */
+  readonly score: number | null;
 }
 interface WallDistribution {
   readonly n: number;
@@ -310,238 +337,23 @@ interface SupervisorRunRollup {
 /**
  * A supervision tree expressed in the canonical rollout row type: one
  * `RolloutLine` per invocation, joined by `parent_rollout_id`. The root row
- * carries `role: 'supervisor'`; every spawned worker carries `role: 'worker'`
- * with the root as its parent.
+ * carries `role: 'supervisor'`; nested supervisors retain that role and leaf
+ * invocations carry `role: 'worker'`.
  */
 interface SupervisorRunTree {
   readonly rootId: string | null;
   readonly nodes: readonly RolloutLine[];
-  /** Why a node could not be recovered, in read order. */
-  readonly gaps: readonly string[];
-}
-//#endregion
-//#region src/supervisor-run/analyze.d.ts
-interface Tokens {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-  /** False when the event carried no cache counters at all — not "zero cached". */
-  hasCache: boolean;
-}
-interface SpendLike {
-  tokens: Tokens;
-  usd: number;
-}
-interface SpawnRow {
-  id: string;
-  parent: string | null;
-  label: string;
-  at: number | null;
-}
-interface CloseRow {
-  id: string;
-  kind: 'settled' | 'cancelled';
-  status: string | null;
-  verdict: string | null;
-  at: number | null;
-  spend: SpendLike;
-  /** False when the close event carried no spend object — not "spent nothing". */
-  hasSpend: boolean;
-}
-interface WorkerLogFacts {
-  started: number | null;
-  /** True once a `finished` event was seen — independent of whether its `at` parsed. */
-  finished: boolean;
-  finishedAt: number | null;
-  passed: boolean | null;
-  /** `patchBytes` as reported by the finished event (not the patch file's size). */
-  finishedPatchBytes: number | null;
-  evidenceBytes: number;
-  steersQueued: number;
-  steersDelivered: number;
-  questions: number;
-}
-/**
- * The tree + timeline the report is computed from, exposed because the rollout-row
- * minter needs exactly the same parse (one parser, two consumers).
- */
-interface SupervisorTreeFacts {
-  readonly rootId: string | null;
-  readonly spawns: readonly SpawnRow[];
-  readonly closes: readonly CloseRow[];
-  readonly workerSpawns: readonly SpawnRow[];
-  readonly workerCloses: readonly CloseRow[];
-  readonly brain: {
-    tokensIn: number;
-    tokensOut: number;
-    cacheRead: number;
-    cacheWrite: number;
-    /** False when no metered event carried cache counters — not "nothing cached". */
-    hasCache: boolean;
-    usd: number;
-    meteredCount: number;
-  };
-  readonly workerLogs: ReadonlyMap<string, WorkerLogFacts>;
-  readonly startedAt: number | null;
-  readonly completedAt: number | null;
-}
-declare function parseSupervisorTree(src: SupervisorRunSources): SupervisorTreeFacts;
-/**
- * Analyze already-read supervisor-run bytes. Pure and synchronous: same bytes
- * in, same report out (modulo `generatedAt`, which `now` pins in tests).
- */
-declare function analyzeSupervisorRunSources(src: SupervisorRunSources, now?: () => number): SupervisorRunReport;
-/** Unified-diff stats. Counts `+++ b/<path>` targets, body +/- lines, and test-file touches. */
-declare function parsePatch(text: string): PatchStats;
-/**
- * Aggregate many supervisor-run reports. A metric no run could measure stays
- * `unavailable` rather than becoming a 0-valued mean, and cells whose steer
- * count was unavailable are counted separately from cells that measured zero.
- */
-declare function rollupSupervisorRuns(reports: readonly SupervisorRunReport[]): SupervisorRunRollup;
-//#endregion
-//#region src/supervisor-run/claude-code-reader.d.ts
-/** Tool names that spawn a child agent. `Task` is the older name for `Agent`. */
-declare const DEFAULT_SPAWN_TOOLS: readonly ['Agent', 'Task'];
-/** Tool names that deliver a message to an ALREADY-RUNNING child agent. */
-declare const DEFAULT_STEER_TOOLS: readonly ['SendMessage'];
-/** Tool names that stop a running child agent. */
-declare const DEFAULT_CANCEL_TOOLS: readonly ['TaskStop', 'KillAgent'];
-interface ClaudeCodeReaderOptions {
-  /** The main session transcript: `~/.claude/projects/<slug>/<sessionId>.jsonl`. */
-  readonly transcriptPath: string;
-  /**
-   * Directory of child transcripts. Defaults to `<transcript-dir>/<sessionId>/subagents`.
-   * `null` skips the join, and every per-worker token count becomes unavailable.
-   */
-  readonly subagentsDir?: string | null;
-  readonly runRef?: string;
-  readonly instanceId?: string | null;
-  readonly arm?: string | null;
-  readonly spawnTools?: readonly string[];
-  readonly steerTools?: readonly string[];
-  readonly cancelTools?: readonly string[];
+  /** Typed reasons a rollout field could not be recovered, in read order. */
+  readonly gaps: readonly SupervisorRunTreeGap[];
 }
-/**
- * Read a Claude Code session (plus its subagent transcripts) as supervision-tree
- * source bytes. Never throws on a missing artifact.
- */
-declare function readClaudeCodeSupervisorRun(opts: ClaudeCodeReaderOptions): Promise<SupervisorRunSources>;
-/** A `SupervisorRunReader` over a Claude Code session — the same contract loops implements. */
-declare function claudeCodeSupervisorRunReader(opts: ClaudeCodeReaderOptions): SupervisorRunReader;
-//#endregion
-//#region src/supervisor-run/loops-reader.d.ts
-/** Locate the (single) supervisor run dir under `<ws>/.loops/supervisor`. */
-declare function findSupervisorRunDirIn(ws: string): Promise<string | null>;
-interface LoopsReaderOptions {
-  /** Override the workspace dir (default `<runDir>/ws`). */
-  readonly ws?: string;
-  /** Delivered patch path (default: `patchPath` from result.json). */
-  readonly patchPath?: string;
-  /** opencode sqlite store; set to `null` to skip the worker-token join entirely. */
-  readonly opencodeDb?: string | null;
-  /** Ledger to fall back to when the run has no `judge.json` (matched on iid + arm + runDir). */
-  readonly ledgerPath?: string;
+/** Stable machine-readable reasons emitted while minting a supervisor tree. */
+type SupervisorRunTreeGapCode = 'journal-unavailable' | 'source-row-malformed' | 'root-spawn-unavailable' | 'root-reward-unavailable' | 'child-reward-unavailable' | 'node-schema-invalid';
+interface SupervisorRunTreeGap {
+  readonly code: SupervisorRunTreeGapCode;
+  readonly message: string;
+  readonly nodeId?: string;
+  readonly count?: number;
 }
-/**
- * Read a loops supervisor run directory into source bytes. Never throws on a
- * missing artifact — an absent file becomes a `null` field, which is what makes
- * the dependent metric `unavailable` instead of 0.
- */
-declare function readLoopsSupervisorRun(runDir: string, opts?: LoopsReaderOptions): Promise<SupervisorRunSources>;
-/** The loops on-disk layout, as a `SupervisorRunReader`. */
-declare function loopsSupervisorRunReader(runDir: string, opts?: LoopsReaderOptions): SupervisorRunReader;
-/**
- * Analyze a supervisor run. Accepts a run directory (read through the loops
- * reader), any `SupervisorRunReader`, or already-read source bytes — so a
- * caller with its own store never has to touch the filesystem layout.
- */
-declare function analyzeSupervisorRun(input: string | SupervisorRunReader | SupervisorRunSources, opts?: LoopsReaderOptions): Promise<SupervisorRunReport>;
-interface WriteSupervisorRunOptions extends LoopsReaderOptions {
-  /** Append the headline block here (the experiment's run log). */
-  readonly appendHeadlineTo?: string;
-  /** Also console.log the headline (default true). */
-  readonly echo?: boolean;
-  /**
-   * Write `run-report.{json,md}` here instead of into the run dir. Set when
-   * reporting over a run directory that must stay READ-ONLY (a live run, an
-   * archived generation).
-   */
-  readonly reportDir?: string;
-}
-/**
- * Read a completed run, write `run-report.json` + `run-report.md` beside its
- * artifacts, and append the headline block to the run log. Never throws on a
- * missing artifact — a run that produced nothing still yields a report whose
- * every metric says why.
- */
-declare function writeSupervisorRunReport(runDir: string, opts?: WriteSupervisorRunOptions): Promise<SupervisorRunReport>;
-/**
- * File stem for out-of-tree reports. Built from the run path's identifying
- * segments — candidate tag (the segment under `arm-runs/`), rep, instance, arm
- * — so two runs of the same instance from different candidates/reps never
- * overwrite each other.
- */
-declare function supervisorReportStem(runDir: string): string;
-/**
- * Best-effort wrapper for a hot path: a reporting failure must never kill a run
- * that already produced real work. Returns null and logs the reason instead.
- */
-declare function writeSupervisorRunReportSafe(runDir: string, opts?: WriteSupervisorRunOptions): Promise<SupervisorRunReport | null>;
-/**
- * Report every run under an experiment `outDir` (any depth of
- * `runs/<iid>/<arm>`), write each run's report, and write the rollup at
- * `<outDir>/run-report-round.{json,md}`.
- */
-declare function reportSupervisorRound(outDir: string, opts?: WriteSupervisorRunOptions & {
-  title?: string;
-}): Promise<SupervisorRunRollup>;
-/** Every `<...>/runs/<iid>/<arm>` directory under `root`. */
-declare function findSupervisorRunDirs(root: string): Promise<string[]>;
-//#endregion
-//#region src/supervisor-run/render.d.ts
-/**
- * The block appended to a run log after every run — the answers an operator asks
- * for, in the log tail, with no extra command.
- */
-declare function renderSupervisorRunHeadline(r: SupervisorRunReport): string;
-declare function renderSupervisorRunMarkdown(r: SupervisorRunReport): string;
-declare function renderSupervisorRollupMarkdown(rollup: SupervisorRunRollup, title?: string): string;
-//#endregion
-//#region src/supervisor-run/rollout-nodes.d.ts
-interface SupervisorRolloutOptions {
-  /** Benchmark/suite id for `task.suite`. Defaults to `'supervisor-run'`. */
-  readonly suite?: string;
-  /** `task.split`. Defaults to `'search'` (the trainable pool). */
-  readonly split?: RolloutSplit;
-  /** Replicate index. Defaults to 0. */
-  readonly rep?: number;
-  /** Sampling seed the campaign pinned. Defaults to null (not recorded). */
-  readonly seed?: number | null;
-  /** `run_id` for every node. Defaults to the supervisor root id, else `runRef`. */
-  readonly runId?: string;
-  /** Harness that drove the supervisor. */
-  readonly supervisorHarness?: string | null;
-  /** Harness that drove the workers. */
-  readonly workerHarness?: string | null;
-  /** Model the supervisor ran on. */
-  readonly supervisorModel?: string | null;
-  /** Model the workers ran on. */
-  readonly workerModel?: string | null;
-  readonly experimentId?: string | null;
-  readonly candidateId?: string | null;
-  readonly generation?: number | null;
-  readonly candidateIndex?: number | null;
-  /** Pins `provenance.captured_at`; defaults to now. */
-  readonly capturedAt?: string;
-}
-/**
- * Mint the supervision tree as rollout rows. Returns the rows plus the gaps
- * that made any of them incomplete — same unavailable-vs-zero discipline as
- * the report: a row with no transcript says WHY, it never pretends to be empty.
- */
-declare function supervisorRunRolloutLines(src: SupervisorRunSources, opts?: SupervisorRolloutOptions): SupervisorRunTree;
 //#endregion
-export { isUnavailable as $, rollupSupervisorRuns as A, RollupCellRow as B, CloseRow as C, analyzeSupervisorRunSources as D, WorkerLogFacts as E, OrchestrationMetrics as F, SupervisorRunReader as G, SUPERVISOR_RUN_SCHEMA as H, OutcomeMetrics as I, SupervisorRunSources as J, SupervisorRunReport as K, PatchStats as L, EconomicsMetrics as M, Measured as N, parsePatch as O, NO_SOURCE_LIMITS as P, WorkerLogSource as Q, PerWorkerRow as R, readClaudeCodeSupervisorRun as S, SupervisorTreeFacts as T, SourceLimits as U, SUPERVISOR_RUN_ROLLUP_SCHEMA as V, SteerBreakdown as W, Unavailable as X, SupervisorRunTree as Y, WallDistribution as Z, ClaudeCodeReaderOptions as _, renderSupervisorRunMarkdown as a, DEFAULT_STEER_TOOLS as b, analyzeSupervisorRun as c, loopsSupervisorRunReader as d, showMeasured as et, readLoopsSupervisorRun as f, writeSupervisorRunReportSafe as g, writeSupervisorRunReport as h, renderSupervisorRunHeadline as i, DecisionMetrics as j, parseSupervisorTree as k, findSupervisorRunDirIn as l, supervisorReportStem as m, supervisorRunRolloutLines as n, LoopsReaderOptions as o, reportSupervisorRound as p, SupervisorRunRollup as q, renderSupervisorRollupMarkdown as r, WriteSupervisorRunOptions as s, SupervisorRolloutOptions as t, unavailable as tt, findSupervisorRunDirs as u, DEFAULT_CANCEL_TOOLS as v, SpawnRow as w, claudeCodeSupervisorRunReader as x, DEFAULT_SPAWN_TOOLS as y, RoleSpend as z };
-//# sourceMappingURL=index-C61Wi7yg.d.ts.map
+export { Unavailable as C, showMeasured as D, isUnavailable as E, unavailable as O, SupervisorRunTreeGapCode as S, WorkerLogSource as T, SupervisorRunReport as _, OrchestrationMetrics as a, SupervisorRunTree as b, PerWorkerRow as c, SUPERVISOR_RUN_ROLLUP_SCHEMA as d, SUPERVISOR_RUN_SCHEMA as f, SupervisorRunReader as g, SupervisorRunNodeRole as h, NO_SOURCE_LIMITS as i, RoleSpend as l, SteerBreakdown as m, EconomicsMetrics as n, OutcomeMetrics as o, SourceLimits as p, Measured as r, PatchStats as s, DecisionMetrics as t, RollupCellRow as u, SupervisorRunRollup as v, WallDistribution as w, SupervisorRunTreeGap as x, SupervisorRunSources as y };
+//# sourceMappingURL=types-Dea6tiVI.d.ts.map

package/dist/types-Dea6tiVI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Dea6tiVI.d.ts","names":[],"sources":["../src/supervisor-run/types.ts"],"mappings":";;;UAiCiB;WACN;;;KAIC,SAAS,KAAK,IAAI;iBAEd,YAAY,iBAAiB;iBAI7B,cAAc,aAAa,KAAK;;iBAKhC,aAAa,GAAG;;KAWpB;;;;;UAMK;;;;;WAKN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;;;;;;;;;;;;;UAcM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;;cAIE,kBAAkB;;;;;;;;;;UAiBd;;WAEN;WACA;;WAEA;;WAEA;;;;;;WAMA;;WAEA;;WAEA;;WAEA;;WAEA,kBAAkB;;WAElB;;WAEA;;;;;;;WAOA;;WAEA;;WAEA;;WAEA;;;;;WAKA;IACP;IACA;IACA;IACA;;IAEA;IACA;;WAEO;;WAEA,QAAQ;;;;;;WAMR;;;;;WAKA;;;;;;UAOM;;WAEN;EACT,QAAQ,QAAQ;;cAOL;cACA;UAEI;;WAEN;WACA;;WAEA;;WAEA;;UAGM;WACN,gBAAgB;WAChB,gBAAgB;WAChB,kBAAkB;;WAElB,QAAQ;WACR,iBAAiB;WACjB,gBAAgB,kBAAkB;;WAElC,kBAAkB;;;;;;WAMlB,OAAO;WACP,WAAW;WACX,gBAAgB;;WAEhB,UAAU;;WAEV,gBAAgB;;WAEhB,iBAAiB;WACjB,oBAAoB;WACpB,kBAAkB;;WAElB,QAAQ;WACR,SAAS;;WAET,mBAAmB;;UAGb;WACN,iBAAiB,SAAS;WAC1B,iBAAiB,SAAS;;WAE1B,UAAU;;WAEV,UAAU;;WAEV,WAAW;;WAEX,oBAAoB;;WAEpB,wBAAwB;;WAExB,eAAe;WACf,qBAAqB;;UAGf;WACN,UAAU;WACV,WAAW;;;;;;WAMX,WAAW;WACX,YAAY;WACZ,KAAK;WACL;;UAGM;;WAEN;WACA;;WAEA,MAAM;WACN;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;UAGM;WACN;WACA;WACA;WACA;WACA;WACA;;UAGM;;WAEN,OAAO;;;;;;;;WAQP,kBAAkB;;WAElB,SAAS;WACT,UAAU;;;;;;WAMV;WACA,yBAAyB;WACzB,0BAA0B,SAAS;WACnC,WAAW,kBAAkB;;UAGvB;WACN;WACA;WACA;WACA;;UAGM;WACN,WAAW;WACX,YAAY;WACZ,WAAW;WACX,eAAe;WACf,YAAY;WACZ,aAAa;WACb,YAAY;WACZ,YAAY;WACZ,UAAU;WACV,OAAO,SAAS;;WAEhB;;UAGM;WACN,eAAe;;WAEf;WACA;WACA;WACA,cAAc;WACd;WACA,eAAe;WACf,UAAU;WACV,WAAW;WACX,SAAS;;WAET;;WAEA;;UAGM;WACN;WACA;WACA,QAAQ;WACR,OAAO;WACP,aAAa;WACb,SAAS;WACT,UAAU;WACV,KAAK;;UAGC;WACN,eAAe;WACf;WACA,aAAa;WACb,iBAAiB;WACjB;WACA,WAAW;WACX,mBAAmB;WACnB,iBAAiB;WACjB,aAAa;WACb,qBAAqB;WACrB,eAAe;WACf,UAAU;WACV,eAAe;WACf,kBAAkB;;;;;;;;UASZ;WACN;WACA,gBAAgB;;WAEhB,eAAe;;;KAId;UAQK;WACN,MAAM;WACN;WACA;WACA"}

package/dist/wire/index.d.ts

@@ -1,7 +1,7 @@
-import { c as CostLedgerHandle } from "../cost-ledger-fGS_u_O1.js";
+import { c as CostLedgerHandle } from "../cost-ledger-D2o6JOrL.js";
+import { Z as LlmRouteRequirements, q as LlmClientOptions } from "../types-CTvKfr5F.js";
 import { s as TraceStore } from "../store-CT9YIIve.js";
-import { o as LlmClientOptions, u as LlmRouteRequirements } from "../llm-client-BiK4HW0u.js";
-import { h as FeedbackTrajectoryStore } from "../feedback-trajectory-CVaeREXV.js";
+import { _ as FeedbackTrajectoryStore } from "../feedback-trajectory-N_F0PwHz.js";
 import { z } from "zod";
 import { ServerType } from "@hono/node-server";
 import { Hono } from "hono";

package/dist/wire/index.js

@@ -1,2 +1,2 @@
-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-Bz3WQJs6.js";
+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-KjXZZUDX.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/feedback-trajectories.md

@@ -55,7 +55,7 @@ const optimizerRows = feedbackTrajectoriesToOptimizerRows([trajectory])
 
 ## What Belongs In Core
 
-`agent-eval` owns the substrate:
+`agent-eval` owns the shared data model:
 
 - trajectory and label schemas
 - in-memory and JSONL-backed stores
@@ -74,6 +74,105 @@ Downstream repos own domain adapters:
 - which budgets and metrics matter
 - where task-local data is stored
 
+## Trace Analyst Bridge
+
+Trace findings are hypotheses until another signal confirms them.
+Use `analystRunToReviewRequests()` to populate a review queue.
+Use `analystRunToFeedbackTrajectory()` immediately to archive the run, even when review has not started.
+The archived trajectory cannot become optimizer input until every finding has one independent decision and the run has one independent completeness assessment.
+
+```ts
+import {
+  analystRunDigest,
+  analystRunToFeedbackTrajectory,
+  analystRunToReviewRequests,
+  feedbackTrajectoryToOptimizerRow,
+} from '@tangle-network/agent-eval'
+
+const runDigest = analystRunDigest(analystRun)
+const requests = analystRunToReviewRequests(analystRun)
+await reviewQueue.add(requests)
+
+const archived = analystRunToFeedbackTrajectory(analystRun, {
+  task: { intent: 'Explain the failed agent run.' },
+  reviewRequests: requests,
+})
+
+await trajectoryStore.save(archived)
+
+declare const reviewedFindingIds: ReadonlySet<string>
+declare const reviewReasons: ReadonlyMap<string, string>
+declare const missedIssues: Array<{
+  id: string
+  reason: string
+  evidence?: Array<{ kind: 'span'; uri: string }>
+}>
+const requestsByFindingId = new Map(requests.map((request) => [request.findingId, request]))
+
+const reviewed = analystRunToFeedbackTrajectory(analystRun, {
+  task: { intent: 'Explain the failed agent run.' },
+  reviewRequests: requests,
+  reviewDecisions: [
+    ...analystRun.findings.map((finding) => ({
+      runDigest,
+      findingId: finding.finding_id,
+      findingDigest: requestsByFindingId.get(finding.finding_id)!.findingDigest,
+      verdict: reviewedFindingIds.has(finding.finding_id) ? 'confirmed' as const : 'rejected' as const,
+      source: 'user' as const,
+      reviewerId: 'reviewer-42',
+      reviewId: 'trace-review-918',
+      reason: reviewReasons.get(finding.finding_id) ?? 'Reviewed against the cited evidence.',
+      decidedAt: new Date().toISOString(),
+    })),
+    {
+      runDigest,
+      verdict: 'completeness_assessed',
+      missedIssues,
+      source: 'user',
+      reviewerId: 'reviewer-42',
+      reviewId: 'trace-review-918',
+      reason: 'Reviewed the full run for findings the analyst omitted.',
+      decidedAt: new Date().toISOString(),
+    },
+  ],
+})
+
+const optimizerRow = feedbackTrajectoryToOptimizerRow(reviewed)
+```
+
+Review requests, generic labels, and run-level outcomes do not validate findings.
+Every request id includes the digest of the complete analyst run, so the same finding in two runs produces two request ids.
+Every decision must echo that run digest and cannot be replayed onto another run.
+Each finding decision must name a known finding and echo its full content digest.
+The reviewer identity must differ from every analyst that produced the run.
+The completeness assessment records unique missed issue ids, reasons, and optional evidence.
+Duplicate, unknown, incomplete, mutated, and self-reviewed data throws instead of being filtered.
+The optimizer score is F1 over confirmed findings and independently identified misses.
+A run with no findings and no missed issues scores `1`.
+The run-level outcome remains context and does not replace that score.
+
+Every run needs one `completeness_assessed` decision from an independent reviewer or environment check:
+
+```ts
+const cleanRunDigest = analystRunDigest(cleanRun)
+const reviewedCleanRun = analystRunToFeedbackTrajectory(cleanRun, {
+  task: { intent: 'Check whether the run has a reportable failure.' },
+  reviewDecisions: [{
+    runDigest: cleanRunDigest,
+    verdict: 'completeness_assessed',
+    missedIssues: [],
+    source: 'environment',
+    reviewerId: 'release-test-suite',
+    reviewId: 'release-check-284',
+    reason: 'The independent release checks found no omitted reportable failure.',
+    decidedAt: new Date().toISOString(),
+  }],
+})
+```
+
+A raw zero-finding run is still valid archival data.
+It is not learning data until completeness is independently assessed.
+
 ## Label Sources
 
 Labels can come from multiple places: