@tangle-network/agent-eval 0.136.0 → 0.138.0

package/dist/types-5q2T25iW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-5q2T25iW.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/{types-DVjczBM9.d.ts → types-BtJhn8v6.d.ts}

@@ -1,7 +1,261 @@
-import { c as CostLedgerHandle } from "./cost-ledger-fGS_u_O1.js";
-import { a as RunRecord, n as RunCostProvenance, u as RunTokenUsage } from "./run-record-DcObtIGh.js";
-import { A as ChatClient, m as JudgeInput } from "./types-Cc3qbqzj.js";
-import { t as TraceAnalysisStore } from "./store-CxJry_cs.js";
+import { c as CostLedgerHandle } from "./cost-ledger-B1D3COAc.js";
+import { a as RunRecord, n as RunCostProvenance, u as RunTokenUsage } from "./run-record-DwHMk1Ai.js";
+import { A as ChatClient, m as JudgeInput } from "./types-5q2T25iW.js";
+import { RE2JS } from "re2js";
+//#region src/trace-analyst/types.d.ts
+/**
+ * Shared types for the trace-analyst module.
+ *
+ * Wire format. The store interface speaks `OtlpSpanLike` rows — one JSONL
+ * line per span, OTLP-shaped. We do NOT depend on a specific tracing
+ * vendor at the type level. Adapter
+ * layers map upstream shapes onto this interface.
+ *
+ * Design constraint. Every read operation that can return arbitrary
+ * payload must carry a byte budget so the agent's tool result stays
+ * bounded regardless of input trace size. Oversized responses
+ * substitute a deterministic summary instead of bytes — see
+ * `ViewTraceOversized`.
+ */
+/** OTLP span kind (subset we actually use). */
+type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'EVALUATOR' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
+type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET';
+/** Subset of OTLP span fields the analyst exposes to the agent. The
+ *  store's job is to project upstream's full span shape down to this
+ *  view — the analyst never sees vendor extensions directly. */
+interface TraceAnalystSpan {
+  trace_id: string;
+  span_id: string;
+  parent_span_id: string | null;
+  name: string;
+  kind: TraceAnalystSpanKind;
+  start_time: string;
+  end_time: string;
+  duration_ms: number;
+  status: TraceAnalystSpanStatus;
+  status_message?: string;
+  service_name: string | null;
+  agent_name: string | null;
+  model_name: string | null;
+  tool_name: string | null;
+  /** Raw JSON-serialisable attribute map. May contain large strings;
+   *  callers must respect the per-attribute byte cap. */
+  attributes: Record<string, unknown>;
+}
+interface TraceAnalystTraceSummary {
+  trace_id: string;
+  service_name: string | null;
+  agent_name: string | null;
+  span_count: number;
+  has_errors: boolean;
+  start_time: string;
+  end_time: string;
+  duration_ms: number;
+  raw_jsonl_bytes: number;
+  models: string[];
+  tools: string[];
+}
+interface TraceAnalystFilters {
+  /** Restrict to traces that contain at least one error span. */
+  has_errors?: boolean;
+  /** Match if any span's `service.name` is in this list. */
+  service_names?: string[];
+  /** Match if any span's `agent.name` is in this list. */
+  agent_names?: string[];
+  /** Match if any LLM span's `llm.model_name` is in this list. */
+  model_names?: string[];
+  /** Match if any tool span's `tool.name` is in this list. */
+  tool_names?: string[];
+  /** ISO-8601 lower bound on the trace's earliest start time. */
+  start_time_after?: string;
+  /** ISO-8601 upper bound on the trace's earliest start time. */
+  start_time_before?: string;
+  /** Single regex applied to raw JSONL bytes for the trace. Opt-in;
+   *  expensive on large datasets. Use the indexed filters above first. */
+  regex_pattern?: string;
+}
+/** One distinct error signature across the dataset — the deterministic unit of
+ *  failure coverage. Signatures normalize volatile tokens (digits, hex/uuids,
+ *  paths, durations) out of the span `status_message` so semantically identical
+ *  failures collapse into one cluster. An analyst that accounts for every
+ *  cluster has, by construction, covered every distinct failure mode. */
+interface ErrorCluster {
+  /** Normalized status_message — the cluster key. */
+  signature: string;
+  /** A verbatim, un-normalized exemplar message (for exact-string citation). */
+  status_message_sample: string;
+  /** The span name that most often carries this signature, if any. */
+  span_name: string | null;
+  /** The tool that most often carries this signature, if any. */
+  tool_name: string | null;
+  trace_count: number;
+  span_count: number;
+  /** trace_count / total error traces in the matched set (0..1). */
+  prevalence: number;
+  /** Real trace ids carrying this signature (capped), passable to view/search. */
+  exemplar_trace_ids: string[];
+  /** Real span ids carrying this signature (capped). */
+  exemplar_span_ids: string[];
+}
+interface DatasetOverview {
+  total_traces: number;
+  raw_jsonl_bytes: number;
+  services: string[];
+  agents: string[];
+  models: string[];
+  tool_names: string[];
+  /** Up to 20 real trace ids the agent may pass to view/search tools. */
+  sample_trace_ids: string[];
+  errors: {
+    trace_count: number;
+    span_count: number;
+  };
+  /** The COMPLETE deterministic error-signature population, sorted by
+   *  trace_count desc. This is the failure-coverage checklist: an analysis is
+   *  complete only when every cluster here is accounted for. Empty when the
+   *  matched set has no error spans. */
+  error_clusters: ErrorCluster[];
+  time_range: {
+    earliest: string;
+    latest: string;
+  } | null;
+}
+interface QueryTracesPage {
+  traces: TraceAnalystTraceSummary[];
+  total: number;
+  has_more: boolean;
+}
+/** Full-trace view. When the response would exceed the per-call byte
+ *  budget, `oversized` is populated INSTEAD of `spans` so the agent
+ *  knows to switch to `searchTrace` / `viewSpans`. */
+interface ViewTraceResult {
+  trace_id: string;
+  spans?: TraceAnalystSpan[];
+  oversized?: ViewTraceOversized;
+}
+interface ViewTraceOversized {
+  span_count: number;
+  /** Names with their counts, sorted desc. Capped at 20 entries. */
+  top_span_names: Array<[string, number]>;
+  /** Largest single span body (bytes after attribute-cap projection). */
+  span_response_bytes_max: number;
+  error_span_count: number;
+}
+interface ViewSpansResult {
+  trace_id: string;
+  spans: TraceAnalystSpan[];
+  /** Number of requested span ids that were not found in the trace. */
+  missing_span_ids: string[];
+  /** Requested span ids that exist but did not fit in this response. */
+  omitted_span_ids: string[];
+  /** True exactly when `omitted_span_ids` contains continuation work. */
+  has_more: boolean;
+  /** Number of attribute fields truncated to fit the per-attribute cap. */
+  truncated_attribute_count: number;
+}
+interface SpanMatchRecord {
+  trace_id: string;
+  span_id: string;
+  span_name: string;
+  span_kind: TraceAnalystSpanKind;
+  /** JSON pointer-style path to the matched value, e.g.
+   *  `attributes."llm.input_messages"[2].content`. */
+  attribute_path: string;
+  matched_text: string;
+  context_before: string;
+  context_after: string;
+  match_offset: number;
+}
+interface SearchTraceResult {
+  trace_id: string;
+  hits: SpanMatchRecord[];
+  has_more: boolean;
+}
+interface SearchSpanResult {
+  trace_id: string;
+  span_id: string;
+  hits: SpanMatchRecord[];
+  has_more: boolean;
+}
+/** Tunable byte budgets for bounded RLM tool output. */
+interface TraceAnalystByteBudgets {
+  /** Max bytes any single tool response may emit. Hard ceiling enforced
+   *  by the store; oversized → summary. Default 150_000. */
+  perCallByteCeiling: number;
+  /** Per-attribute string truncation cap on `viewTrace` (discovery scan).
+   *  Default 4096. */
+  perAttributeViewBudget: number;
+  /** Per-attribute string truncation cap on `viewSpans` (surgical reads).
+   *  Default 16384. */
+  perAttributeSpanBudget: number;
+  /** Per-attribute cap on a single match record's `matched_text` and
+   *  context window. Default 1024. */
+  perMatchTextBudget: number;
+}
+declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
+/** Marker substituted in place of truncated string payloads. Callers
+ *  parsing tool output can detect it deterministically. */
+declare const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
+//#endregion
+//#region src/trace-analyst/store-contract.d.ts
+declare const TRACE_ANALYSIS_LIMITS: {
+  readonly sampleTraceIds: 20;
+  readonly queryTraces: 200;
+  readonly viewSpans: 100;
+  readonly searchMatches: 500;
+  readonly filterValues: 100;
+  readonly identifierCharacters: 256;
+  readonly regexCharacters: 4096;
+  readonly minimumTextBudget: 64;
+};
+interface TraceAnalysisStoreContext {
+  signal?: AbortSignal;
+}
+/**
+ * Storage adapter for trace reads.
+ *
+ * Bind third-party implementations with `createBoundedTraceAnalysisStore()`.
+ * The binding validates every input and result, applies byte limits, and
+ * forwards one cancellation signal through existence checks and reads.
+ */
+interface TraceAnalysisStore {
+  hasTrace(trace_id: string, context?: TraceAnalysisStoreContext): Promise<boolean>;
+  hasSpans(input: {
+    trace_id: string;
+    span_ids: readonly string[];
+  }, context?: TraceAnalysisStoreContext): Promise<string[]>;
+  getOverview(filters?: TraceAnalystFilters, context?: TraceAnalysisStoreContext): Promise<DatasetOverview>;
+  queryTraces(input: {
+    filters?: TraceAnalystFilters;
+    limit: number;
+    offset?: number;
+  }, context?: TraceAnalysisStoreContext): Promise<QueryTracesPage>;
+  countTraces(filters?: TraceAnalystFilters, context?: TraceAnalysisStoreContext): Promise<number>;
+  viewTrace(input: {
+    trace_id: string;
+    per_attribute_byte_cap?: number;
+  }, context?: TraceAnalysisStoreContext): Promise<ViewTraceResult>;
+  viewSpans(input: {
+    trace_id: string;
+    span_ids: readonly string[];
+    per_attribute_byte_cap?: number;
+  }, context?: TraceAnalysisStoreContext): Promise<ViewSpansResult>;
+  searchTrace(input: {
+    trace_id: string;
+    regex_pattern: string;
+    max_matches?: number;
+  }, context?: TraceAnalysisStoreContext): Promise<SearchTraceResult>;
+  searchSpan(input: {
+    trace_id: string;
+    span_id: string;
+    regex_pattern: string;
+    max_matches?: number;
+  }, context?: TraceAnalysisStoreContext): Promise<SearchSpanResult>;
+}
+interface BoundedTraceAnalysisStoreOptions {
+  budgets?: Partial<TraceAnalystByteBudgets>;
+}
+//#endregion
 //#region src/analyst/types.d.ts
 /**
  * Unified envelope every analyst emits. Schema-versioned so renderers
@@ -272,5 +526,5 @@ type AnalystRunEvent = {
   result: AnalystRunResult;
 };
 //#endregion
-export { makeFinding as _, AnalystInputKind as a, AnalystRunInputs as c, AnalystSeverity as d, AnalystUsageReceipt as f, computeFindingId as g, ProposalFindingOrigin as h, AnalystFinding as i, AnalystRunResult as l, ProposalFinding as m, AnalystContext as n, AnalystRequirements as o, EvidenceRef as p, AnalystCost as r, AnalystRunEvent as s, Analyst as t, AnalystRunSummary as u, makeProposalFinding as v };
-//# sourceMappingURL=types-DVjczBM9.d.ts.map
+export { TRACE_ANALYST_TRUNCATION_MARKER_PREFIX as A, DEFAULT_TRACE_ANALYST_BUDGETS as C, SearchSpanResult as D, QueryTracesPage as E, TraceAnalystSpanStatus as F, TraceAnalystTraceSummary as I, ViewSpansResult as L, TraceAnalystFilters as M, TraceAnalystSpan as N, SearchTraceResult as O, TraceAnalystSpanKind as P, ViewTraceOversized as R, TraceAnalysisStoreContext as S, ErrorCluster as T, makeFinding as _, AnalystInputKind as a, TRACE_ANALYSIS_LIMITS as b, AnalystRunInputs as c, AnalystSeverity as d, AnalystUsageReceipt as f, computeFindingId as g, ProposalFindingOrigin as h, AnalystFinding as i, TraceAnalystByteBudgets as j, SpanMatchRecord as k, AnalystRunResult as l, ProposalFinding as m, AnalystContext as n, AnalystRequirements as o, EvidenceRef as p, AnalystCost as r, AnalystRunEvent as s, Analyst as t, AnalystRunSummary as u, makeProposalFinding as v, DatasetOverview as w, TraceAnalysisStore as x, BoundedTraceAnalysisStoreOptions as y, ViewTraceResult as z };
+//# sourceMappingURL=types-BtJhn8v6.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-BtJhn8v6.d.ts","names":[],"sources":["../src/trace-analyst/types.ts","../src/trace-analyst/store-contract.ts","../src/analyst/types.ts"],"mappings":"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"}

package/dist/{index-CyC1BTmn.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 {
@@ -12,7 +12,10 @@ declare function isUnavailable(v: unknown): v is Unavailable;
 declare function showMeasured(v: Measured<number | string | boolean | null>): string;
 /** The two invocation roles a recursive supervision tree can contain. */
 type SupervisorRunNodeRole = 'supervisor' | 'worker';
-/** One worker's logs, as read. `null` = the artifact did not exist. */
+/**
+ * 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
@@ -340,242 +343,17 @@ interface SupervisorRunRollup {
 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;
-  role: SupervisorRunNodeRole;
-  at: number | null;
-}
-interface CloseRow {
-  id: string;
-  kind: 'settled' | 'cancelled';
-  status: string | null;
-  /** String verdict from legacy journals, or valid/invalid for a structured verdict. */
-  verdict: string | null;
-  /** Structured verdict validity, when recorded. */
-  valid: boolean | null;
-  /** Structured verdict score, preserved without boolean coercion. */
-  score: number | null;
-  /** The verdict exactly as the journal carried it. */
-  rawVerdict: unknown | 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;
-  /** Numeric score exactly as the finished event recorded it. */
-  score: number | 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[];
-}
-/**
- * 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;
+  /** Typed reasons a rollout field could not be recovered, in read order. */
+  readonly gaps: readonly SupervisorRunTreeGap[];
 }
-/**
- * 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;
+/** 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 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 { WorkerLogSource as $, rollupSupervisorRuns as A, RollupCellRow as B, CloseRow as C, analyzeSupervisorRunSources as D, WorkerLogFacts as E, OrchestrationMetrics as F, SupervisorRunNodeRole as G, SUPERVISOR_RUN_SCHEMA as H, OutcomeMetrics as I, SupervisorRunRollup as J, SupervisorRunReader as K, PatchStats as L, EconomicsMetrics as M, Measured as N, parsePatch as O, NO_SOURCE_LIMITS as P, WallDistribution as Q, PerWorkerRow as R, readClaudeCodeSupervisorRun as S, SupervisorTreeFacts as T, SourceLimits as U, SUPERVISOR_RUN_ROLLUP_SCHEMA as V, SteerBreakdown as W, SupervisorRunTree as X, SupervisorRunSources as Y, Unavailable as Z, ClaudeCodeReaderOptions as _, renderSupervisorRunMarkdown as a, DEFAULT_STEER_TOOLS as b, analyzeSupervisorRun as c, loopsSupervisorRunReader as d, isUnavailable 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, unavailable as nt, LoopsReaderOptions as o, reportSupervisorRound as p, SupervisorRunReport as q, renderSupervisorRollupMarkdown as r, WriteSupervisorRunOptions as s, SupervisorRolloutOptions as t, showMeasured 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-CyC1BTmn.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/{types-DiWLru6Z.d.ts → types-zFYez3PK.d.ts}

@@ -1,7 +1,7 @@
-import { S as PaidCallResult, T as RunPaidCallInput, a as CostChannel, c as CostLedgerHandle, f as CostLedgerSummary } from "./cost-ledger-fGS_u_O1.js";
-import { u as RunTokenUsage } from "./run-record-DcObtIGh.js";
-import { n as LlmCallMetadata } from "./llm-client-BiK4HW0u.js";
-import { m as ProposalFinding } from "./types-DVjczBM9.js";
+import { S as PaidCallResult, T as RunPaidCallInput, a as CostChannel, c as CostLedgerHandle, f as CostLedgerSummary } from "./cost-ledger-B1D3COAc.js";
+import { u as RunTokenUsage } from "./run-record-DwHMk1Ai.js";
+import { U as LlmCallMetadata } from "./types-5q2T25iW.js";
+import { m as ProposalFinding } from "./types-BtJhn8v6.js";
 //#region src/campaign/types.d.ts
 /** Stable identifier + kind tag for any scenario. Consumers
  *  extend with their per-domain payload (persona, task, requirement, ...). */
@@ -620,4 +620,4 @@ interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scena
 }
 //#endregion
 export { LabeledScenarioWrite as A, ScoredSurfaceOutcome as B, JudgeDimension as C, LabeledScenarioSampleArgs as D, LabeledScenarioRecord as E, ProposeContext as F, labelTrustRank as G, SurfaceProposer as H, ProposedCandidate as I, RedactionStatus as L, OptimizerConfig as M, ParetoParent as N, LabeledScenarioSource as O, ProposalTrackContext as P, Scenario as R, JudgeConfig as S, LabelTrust as T, TraceSpan as U, SessionScript as V, isProposedCandidate as W, GateDecision as _, CampaignResult as a, GenerationRecord as b, CampaignTraceWriter as c, DispatchContext as d, DispatchFn as f, GateContribution as g, GateContext as h, CampaignCostMeter as i, MutableSurface as j, LabeledScenarioStore as k, CodeSurface as l, GateCheckStatus as m, CampaignArtifactWriter as n, CampaignScenarioIdentity as o, Gate as p, CampaignCellResult as r, CampaignTokenUsage as s, CampaignAggregates as t, ComponentSurface as u, GateResult as v, JudgeScore as w, JudgeAggregate as x, GenerationCandidate as y, ScenarioAggregate as z };
-//# sourceMappingURL=types-DiWLru6Z.d.ts.map
+//# sourceMappingURL=types-zFYez3PK.d.ts.map

package/dist/{types-DiWLru6Z.d.ts.map → types-zFYez3PK.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-DiWLru6Z.d.ts","names":[],"sources":["../src/campaign/types.ts"],"mappings":"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"}
+{"version":3,"file":"types-zFYez3PK.d.ts","names":[],"sources":["../src/campaign/types.ts"],"mappings":"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"}

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-B1D3COAc.js";
+import { Z as LlmRouteRequirements, q as LlmClientOptions } from "../types-5q2T25iW.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-CoNep7rl.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-DLEvyW2z.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 };