@tangle-network/traces 0.10.2 → 0.11.0

package/dist/index.d.ts

@@ -5,6 +5,8 @@ export { Analyst, AnalystContext, AnalystFinding, AnalystRegistry, buildDefaultA
 import { ExecutionReport } from '@tangle-network/agent-eval/contract';
 import { TraceAnalysisStore, RedactionRule, RedactionReport } from '@tangle-network/agent-eval/traces';
 export { DEFAULT_REDACTION_RULES, ErrorCluster, RedactionReport, RedactionRule, TraceAnalysisStore, redactString, redactValue } from '@tangle-network/agent-eval/traces';
+import { SpawnEvent, NodeStatus, Runtime, Budget, Spend } from '@tangle-network/agent-runtime/kernel';
+import { SupervisorRunNodeRole, SupervisorRunReader, SupervisorRunSources } from '@tangle-network/agent-eval/supervisor-run';
 import { TraceSpanEvent } from '@tangle-network/agent-eval/hosted';
 export { HostedClient, createHostedClient, hostedClientFromEnv } from '@tangle-network/agent-eval/hosted';
 
@@ -2052,6 +2054,512 @@ interface ObserverOptions {
 }
 declare function watchSessions(opts: ObserverOptions): Promise<void>;
 
+/**
+ * A SECOND implementation of agent-eval's `SupervisorRunReader` port, over the
+ * run directory that agent-runtime's `createFileRunContext(dir)` writes:
+ *
+ *   <runDir>/spawn-journal.jsonl     required — the append-only SpawnEvent log
+ *   <runDir>/coordination-log.jsonl  optional — steer / delivery / question / settled
+ *   <runDir>/blobs/                  optional — content-addressed settled results
+ *   <runDir>/result.json             optional — the terminal outcome document
+ *
+ * `loopsSupervisorRunReader` is the other implementation, over a completely
+ * different layout. Neither knows about the other, and NOTHING here analyzes:
+ * `analyzeSupervisorRun` / `parseSupervisorTree` / `rollupSupervisorRuns` in
+ * `@tangle-network/agent-eval/supervisor-run` compute every metric, and
+ * `materializeTreeView` in `@tangle-network/agent-runtime/kernel` folds the
+ * event log into the tree. This file is translation only.
+ *
+ * ## Two translations, both faithful
+ *
+ * 1. **The envelope.** agent-runtime's `FileSpawnJournal` writes each event
+ *    wrapped as `{kind:'event', root, event:{…}}` after one `{kind:'begin'}`
+ *    record. agent-eval's parser reads `kind` at the TOP level, so an
+ *    un-translated file parses as zero spawns AND zero malformed rows — a run
+ *    that reads as "the supervisor did nothing" rather than "I cannot read
+ *    this". The reader unwraps the envelope and re-emits flat JSONL.
+ *
+ * 2. **`role`.** `SupervisorRunSources.journal` documents
+ *    `role: 'supervisor' | 'worker'` on spawned rows for recursive readers.
+ *    agent-runtime's `SpawnEvent` has no such field, so it is INFERRED
+ *    structurally and exactly: a node that appears as another spawn's `parent`
+ *    is a supervisor; the root is a supervisor because it has no parent;
+ *    everything else is a worker. No new upstream field is needed for this,
+ *    and no depth limit applies — `<root>:s0:s0` classifies its parent
+ *    `<root>:s0` as a supervisor by the same rule that classifies the root.
+ *
+ * Steer traffic is translated the same way: this layout records steers in
+ * `coordination-log.jsonl` rather than per-worker inbox files, and each
+ * recorded field maps 1:1 onto the per-worker artifacts the analyzer reads.
+ * Nothing is synthesized from an absent fact — an artifact this layout does
+ * not keep is declared in `SourceLimits`, which is what turns the dependent
+ * metric into `unavailable` instead of 0.
+ */
+
+declare const SPAWN_JOURNAL_FILE = "spawn-journal.jsonl";
+declare const COORDINATION_LOG_FILE = "coordination-log.jsonl";
+declare const RESULT_FILE = "result.json";
+declare const BLOBS_DIR = "blobs";
+interface RunContextJournal {
+    /** The `root` of the `begin` record, or of the first event envelope. */
+    readonly root: string | null;
+    /** ISO instant the tree was begun, when a `begin` record was written. */
+    readonly begunAt: string | null;
+    /** Events in file order, unwrapped from their envelopes. */
+    readonly events: readonly SpawnEvent[];
+    /** Node ids that appear as some spawn's `parent` — the exact supervisor set. */
+    readonly supervisorIds: ReadonlySet<string>;
+    readonly invalidRows: number;
+    readonly partialTail: boolean;
+    readonly present: boolean;
+}
+/**
+ * Unwrap `FileSpawnJournal`'s `{kind:'begin'|'event', root, event}` records.
+ * A record whose `kind` is neither is counted as invalid rather than dropped:
+ * an unrecognized record shape is a finding, not silence.
+ */
+declare function readRunContextJournal(text: string | null): RunContextJournal;
+/**
+ * A node's role, decided by the tree's own shape. `supervisorIds` is the set of
+ * ids some spawn named as its parent, so the rule is exact at any depth and
+ * needs no field agent-runtime does not emit.
+ */
+declare function inferRole(id: string, parent: string | null | undefined, supervisorIds: ReadonlySet<string>): SupervisorRunNodeRole;
+/** One steer the driver sent down to a named node. */
+interface CoordinationSteer {
+    readonly messageId: string | null;
+    readonly toWorker: string | null;
+    readonly instruction: string;
+    readonly deliveryMode: string | null;
+    readonly at: number | null;
+}
+/** A question a node raised up. `blocking` is the run-stopping urgency. */
+interface CoordinationQuestion {
+    readonly id: string | null;
+    readonly from: string | null;
+    readonly question: string;
+    readonly reason: string | null;
+    readonly urgency: string | null;
+    readonly status: string | null;
+    readonly blocking: boolean;
+    readonly at: number | null;
+}
+interface CoordinationLog {
+    readonly present: boolean;
+    readonly steers: readonly CoordinationSteer[];
+    /** `messageId → delivered`, from `delivery` receipts. */
+    readonly deliveries: readonly {
+        messageId: string | null;
+        delivered: boolean | null;
+    }[];
+    readonly questions: readonly CoordinationQuestion[];
+    readonly invalidRows: number;
+    readonly partialTail: boolean;
+}
+/**
+ * Two record envelopes are in the wild for this file: the versioned
+ * `{version, runId, source, record:{seq, at, event}}` and the flat
+ * `{runId, at, event}`. Both carry the same `event`, so the unwrap is a single
+ * lookup and neither shape is privileged.
+ */
+declare function readCoordinationLog(text: string | null): CoordinationLog;
+interface FileRunContextReaderOptions {
+    /** Override the run identity used for rollup grouping (default: the journal root). */
+    readonly instanceId?: string | null;
+    /** Which arm of a comparison this run is (default: the run directory's basename). */
+    readonly arm?: string | null;
+}
+/**
+ * Read a `createFileRunContext` run directory into `SupervisorRunSources`.
+ * Never throws on a missing artifact: an absent file becomes a `null` field or
+ * a declared `SourceLimits` reason, which is what makes the dependent metric
+ * `unavailable` rather than 0.
+ */
+declare function readFileRunContext(runDir: string, opts?: FileRunContextReaderOptions): Promise<SupervisorRunSources>;
+/** The `createFileRunContext` on-disk layout, as a `SupervisorRunReader`. */
+declare function fileRunContextSupervisorRunReader(runDir: string, opts?: FileRunContextReaderOptions): SupervisorRunReader;
+/** Does this directory hold a `createFileRunContext` run? */
+declare function isFileRunContextDir(runDir: string): Promise<boolean>;
+/**
+ * A sum over spend records that keeps "unknown" out of the number.
+ *
+ * `usd` is the total of the records that priced themselves; `usdUnknown` is how
+ * many declined to. A renderer that has 0 known records and >=1 unknown one must
+ * print "unknown", never `$0.0000`: an unmetered turn and a free turn are
+ * different facts, and agent-runtime's `Spend.usdKnown` is the only signal that
+ * separates them (absent means known, per its contract).
+ */
+interface SpendRoll {
+    readonly records: number;
+    readonly iterations: number;
+    readonly tokensIn: number;
+    readonly tokensOut: number;
+    readonly usd: number;
+    readonly usdKnownRecords: number;
+    readonly usdUnknownRecords: number;
+}
+declare const ZERO_ROLL: SpendRoll;
+declare function addSpend(roll: SpendRoll, spend: Spend): SpendRoll;
+declare function mergeRolls(a: SpendRoll, b: SpendRoll): SpendRoll;
+interface RunContextNode {
+    readonly id: string;
+    readonly parent: string | null;
+    readonly label: string;
+    readonly depth: number;
+    readonly role: SupervisorRunNodeRole;
+    readonly status: NodeStatus;
+    readonly runtime: Runtime | null;
+    /** The budget this node was AUTHORED with, exactly as the spawn recorded it. */
+    readonly budget: Budget;
+    /** This node's own driver inference — its `metered` events. */
+    readonly driver: SpendRoll;
+    /** What this node's direct children consumed — their `settled` spend. */
+    readonly children: SpendRoll;
+    /** What this node's own settlement charged its parent (its whole subtree). */
+    readonly settled: SpendRoll;
+    readonly spawnedAt: number | null;
+    readonly settledAt: number | null;
+    /** Wall from spawn to settlement; null while the node is still live. */
+    readonly wallMs: number | null;
+    readonly outRef: string | null;
+    /** Why a cancelled node was cancelled. */
+    readonly cancelReason: string | null;
+}
+interface RunContextResult {
+    readonly kind: string | null;
+    readonly reason: string | null;
+    readonly errorName: string | null;
+    readonly errorMessage: string | null;
+}
+interface RunContextSnapshot {
+    readonly runDir: string;
+    readonly runId: string | null;
+    readonly present: boolean;
+    /** Depth-first, parents before children. */
+    readonly nodes: readonly RunContextNode[];
+    readonly maxDepth: number;
+    readonly begunAt: number | null;
+    /** Latest instant any event carried. */
+    readonly lastEventAt: number | null;
+    readonly questions: readonly CoordinationQuestion[];
+    readonly steers: readonly CoordinationSteer[];
+    readonly result: RunContextResult | null;
+    /** True once `result.json` exists — the run has reached a terminal state. */
+    readonly terminal: boolean;
+    /** Rows that were present and unreadable, per artifact. */
+    readonly invalidJournalRows: number;
+    readonly invalidCoordinationRows: number;
+    /** True when an artifact's last line was still being written. */
+    readonly partialTail: boolean;
+    /** Why the tree could not be folded, when it could not. */
+    readonly treeError: string | null;
+}
+/**
+ * Read the run directory into the shape a live view renders. The tree comes
+ * from agent-runtime's own `materializeTreeView` — the owner's fold of its own
+ * event log, so a new event kind stays correctly classified here without this
+ * file changing.
+ *
+ * The one thing the fold deliberately does NOT answer is the split this view
+ * exists for: `materializeTreeView` accumulates a node's `metered` driver
+ * inference ONTO its settled child-work base, which is the right total and the
+ * wrong breakdown. Driver and child spend are therefore rolled separately
+ * straight off the events, which is a partition of the same rows, not a second
+ * tree.
+ */
+declare function readRunContextSnapshot(runDir: string): Promise<RunContextSnapshot>;
+
+/**
+ * The GENERAL run-tree source: reconstruct a run's shape from OTLP spans alone.
+ *
+ * `supervisor-run-context.ts` is the specific source — agent-runtime's durable
+ * spawn journal, which carries the exact authored budget, settled spend, and
+ * settlement status that telemetry does not. This file is the one that works
+ * for emitters nobody has written yet: anything that emits spans carrying
+ * `trace_id` / `span_id` / `parent_span_id` gets a tree, because the parent
+ * pointer IS the tree. A supervisor, a pi session, a Claude subagent fan-out,
+ * and a custom fanout all reach the same view through the same three fields.
+ *
+ * ## Nothing here is a second exporter or a second attribute vocabulary
+ *
+ * Spans are read with this repo's existing `exportTraceEvidenceFile`, which
+ * already detects OpenInference / intelligence-span / sandbox-event files,
+ * normalizes them onto `OtlpSpan`, redacts, and validates. Every attribute is
+ * read through `@tangle-network/agent-eval/trace-attributes` alias lists
+ * (`LLM_INPUT_TOKEN_ATTR_KEYS`, `LLM_COST_ATTR_KEYS`, `SPAN_KIND_ATTR_KEYS`, …),
+ * which already cover both live vocabularies — OpenInference's
+ * `llm.token_count.*` and GenAI semconv's `gen_ai.usage.*`. No key is invented
+ * here, so a span this repo can already read is a span this view can already
+ * place.
+ *
+ * ## What a span tree can and cannot say
+ *
+ * It can say the shape, the wall time, the tokens, and — when the emitter
+ * priced them — the dollars. It CANNOT say the authored budget: neither
+ * vocabulary carries a spawn's ceiling, so budget is reported as absent, never
+ * as 0. That gap is exactly why the journal source exists and why, when both
+ * are present, the journal's numbers win.
+ */
+
+type SpanNodeStatus = 'running' | 'done' | 'failed';
+interface SpanRunNode {
+    readonly traceId: string;
+    readonly spanId: string;
+    /** The enclosing NODE's span id — not necessarily the raw parent span. */
+    readonly parentNodeId: string | null;
+    readonly label: string;
+    readonly depth: number;
+    /**
+     * `driver` when this node has nested agent nodes below it, `leaf` otherwise.
+     * Spans carry no spawn relationship, so delegation is read from the tree
+     * itself — the only fact the telemetry actually states.
+     */
+    readonly role: 'driver' | 'leaf';
+    readonly status: SpanNodeStatus;
+    /** `service.name` — which harness or runtime emitted this subtree. */
+    readonly runtime: string | null;
+    /** This node's OWN inference: the LLM spans it emitted directly. */
+    readonly driver: SpendRoll;
+    /** What its nested agent nodes consumed, whole subtrees included. */
+    readonly children: SpendRoll;
+    /** Tool spans attributed to this node directly. */
+    readonly toolCalls: number;
+    readonly startMs: number;
+    readonly endMs: number;
+    readonly wallMs: number;
+    /** Span status messages on this node or its non-node descendants. */
+    readonly errors: readonly string[];
+}
+interface SpanRunSnapshot {
+    readonly source: string;
+    readonly present: boolean;
+    /** Depth-first, parents before children, one subtree per trace. */
+    readonly nodes: readonly SpanRunNode[];
+    readonly maxDepth: number;
+    readonly traceIds: readonly string[];
+    readonly spanCount: number;
+    readonly startMs: number | null;
+    readonly endMs: number | null;
+    /** LLM spans that recorded no token count at all — a gap, not a zero. */
+    readonly llmSpansWithoutTokens: number;
+    /** LLM spans that recorded no cost at all — a gap, not $0. */
+    readonly llmSpansWithoutCost: number;
+    /** Spans whose `parent_span_id` names a span not in the file. */
+    readonly orphanSpans: number;
+    /** Why the file could not be read, when it could not. */
+    readonly readError: string | null;
+}
+declare const EMPTY_SPAN_RUN_SNAPSHOT: Omit<SpanRunSnapshot, 'source'>;
+/**
+ * Fold a flat span batch into the node tree. Pure, so the same spans always
+ * render the same text — which is what lets the live tail print only on change.
+ */
+declare function buildSpanRunTree(spans: readonly OtlpSpan[], source: string): SpanRunSnapshot;
+/**
+ * Read one span file into a snapshot. Never throws: a tail that catches the
+ * writer mid-line, or an empty file the emitter has not filled yet, is a state
+ * to display, not a crash.
+ */
+declare function readSpanRunSnapshot(path: string): Promise<SpanRunSnapshot>;
+/**
+ * The two run-level halves of a span tree, each counted exactly once: the
+ * inference emitted by nodes that DELEGATED, and the inference emitted by the
+ * leaves they delegated to. Every LLM span lands in exactly one half, so the
+ * two add up to the run and neither hides inside the other.
+ */
+declare function spanRunTotals(snapshot: SpanRunSnapshot): {
+    driver: SpendRoll;
+    leaves: SpendRoll;
+};
+/** The rendered view for one span snapshot. Pure. */
+declare function renderSpanRunSnapshot(snapshot: SpanRunSnapshot): string;
+/**
+ * Span files at or immediately under `dir`. One level only, matching how the
+ * journal source resolves a run directory: a run is the unit a caller names.
+ */
+declare function findSpanSourceFiles(dir: string): Promise<string[]>;
+
+/**
+ * `traces watch <runDir>` — a live terminal view of a supervised run written by
+ * agent-runtime's `createFileRunContext`.
+ *
+ * Plain stdout, no dependency, no cursor control: it works over SSH, in a CI
+ * log, and through a pipe, and it prints a new block only when something
+ * changed, so a long idle stretch does not scroll away the last real event.
+ *
+ * The whole view model comes from `readRunContextSnapshot`; this file only
+ * formats. Two formatting rules carry the weight:
+ *
+ *  - **Driver inference and child work never merge.** A supervisor's own
+ *    thinking and the work it spawned are separate lines on the same node,
+ *    because a single total cannot answer "which half spent the budget" — the
+ *    decisive question in three real runs, where a root burned its pool on its
+ *    own turns while its one child cost almost nothing.
+ *  - **Unknown is never rendered as zero.** `Spend.usdKnown === false` means
+ *    the harness did not price that inference; it does not mean the inference
+ *    was free. Those records are counted and named, never summed into `$0.00`.
+ */
+
+/**
+ * The whole view for one snapshot. Pure: the same snapshot always renders the
+ * same text, which is what lets the tail print only on change.
+ */
+declare function renderRunContextSnapshot(snapshot: RunContextSnapshot): string;
+/**
+ * The two run-level halves, each counted exactly once.
+ *
+ * Driver total sums every node's OWN `metered` inference, at any depth. Worker
+ * total sums the settled spend of LEAF nodes only, because a nested
+ * supervisor's settlement re-homes its whole subtree up to its parent — adding
+ * it would count every grandchild twice, and the sub-total would silently
+ * exceed the pool the run actually spent.
+ */
+declare function runTotals(snapshot: RunContextSnapshot): {
+    driver: SpendRoll;
+    workers: SpendRoll;
+};
+/**
+ * Resolve what the user pointed at: the run directory itself, or a parent
+ * holding exactly one. A parent holding several is ambiguous and says so with
+ * the candidates, rather than picking one.
+ */
+declare function resolveRunContextDir(dir: string): Promise<string>;
+
+/**
+ * Formatting primitives shared by every `traces watch <target>` view.
+ *
+ * Two rules live here rather than in each renderer, because they are the whole
+ * reason this view exists and a second copy would eventually disagree with the
+ * first:
+ *
+ *  - **Unknown is never rendered as zero.** A roll with no priced record prints
+ *    "cost unknown", not `$0.0000`. An unmetered turn and a free turn are
+ *    different facts.
+ *  - **A recorded $0 that burned tokens is printed AND flagged.** The recorded
+ *    value stands; the ambiguity is named next to it.
+ *
+ * Plain ASCII-plus-box-drawing, no cursor control and no colour: the output has
+ * to survive SSH, a CI log, and a pipe into a file.
+ */
+
+declare const RULE: string;
+declare function int(n: number): string;
+declare function ms(value: number | null): string;
+/**
+ * A dollar figure that keeps unknown out of the number. With no priced record
+ * at all the answer is "cost unknown" — printing `$0.0000` there is the exact
+ * fabrication this view exists to prevent.
+ */
+declare function usd(roll: SpendRoll): string;
+/**
+ * A roll that claims a price of exactly $0 while recording real tokens.
+ *
+ * agent-runtime's contract is that `Spend.usdKnown` absent means the dollar
+ * figure IS known, so the honest number is $0 and this view prints it. But a
+ * harness-billed brain (a CLI on a subscription) also records $0 without ever
+ * setting `usdKnown:false`, and "free" and "unmetered" are the two facts this
+ * view exists to keep apart. So the value stands and the ambiguity is named —
+ * never the reverse.
+ */
+declare function zeroPricedCost(roll: SpendRoll): boolean;
+declare function tokens(roll: SpendRoll): string;
+declare const STATUS_MARK: Record<string, string>;
+/**
+ * Tree connectors for a depth-first node list. `lastAtDepth` records, per
+ * ancestor level, whether that ancestor was its parent's last child, which is
+ * what decides between a continuing `│` and a blank column — the difference
+ * between a readable tree and an ambiguous indent at depth 3+.
+ */
+declare function connectors(depth: number, lastAtDepth: readonly boolean[]): {
+    head: string;
+    detail: string;
+};
+/**
+ * Walk a depth-first node list, handing each node the `lastAtDepth` state its
+ * connectors need. A node is its parent's last child when no later node shares
+ * that parent, which the caller's list order already encodes.
+ */
+declare function forEachTreeNode<T extends {
+    readonly depth: number;
+}>(nodes: readonly T[], parentKey: (node: T) => string | null, selfKey: (node: T) => string, visit: (node: T, lastAtDepth: readonly boolean[]) => void): void;
+/** Wrap to a terminal width so a long question is readable, never truncated. */
+declare function wrap(text: string, indent: number): string[];
+
+/**
+ * `traces watch <target>` — the live terminal view, over whichever sources the
+ * target actually has.
+ *
+ * Two sources, one verb:
+ *
+ *  - **General** — `run-span-tree.ts`, over OTLP spans. `trace_id` /
+ *    `span_id` / `parent_span_id` reconstruct the tree for ANY emitter, so a
+ *    system nobody has written yet is watchable the day it emits its first
+ *    span. It cannot report an authored budget, because no span vocabulary
+ *    carries one.
+ *  - **Specific** — `supervisor-run-context.ts`, over agent-runtime's durable
+ *    spawn journal. It carries the exact budget, spend, and settlement the
+ *    telemetry does not.
+ *
+ * When a run has both, the output shows both and LABELS which number came from
+ * which: the journal section first, because its numbers are the authoritative
+ * ones, then the span section for the shape and the per-turn detail. They are
+ * never merged into one column, because a merged column cannot be audited —
+ * and the numbers legitimately differ (a driver's spans price each turn; the
+ * journal's `settled` re-homes a whole subtree onto its parent).
+ *
+ * Plain stdout, no dependency, no cursor control: it works over SSH, in a CI
+ * log, and through a pipe. A block prints only when the rendered view changed,
+ * so a long idle stretch never scrolls the last real event away.
+ */
+
+/** What a resolved target will be read from. At least one is always present. */
+interface RunWatchTarget {
+    /** The directory holding `spawn-journal.jsonl`, when there is one. */
+    readonly runDir: string | null;
+    /** OTLP span files to fold, in read order. */
+    readonly spanFiles: readonly string[];
+    /** What the caller named, verbatim — the thing to print in an error. */
+    readonly requested: string;
+}
+/**
+ * Resolve what the user pointed at.
+ *
+ * A file the caller named is read as spans, whatever it is called. A directory
+ * is the run directory when it holds a spawn journal, or the parent of exactly
+ * one — the same rule `resolveRunContextDir` already applies — and either way
+ * its span files come along. A directory with neither is an error naming both
+ * things it looked for, because "nothing here" and "wrong kind of thing here"
+ * are different mistakes.
+ */
+declare function resolveRunWatchTarget(target: string): Promise<RunWatchTarget>;
+interface RunWatchSnapshot {
+    readonly target: RunWatchTarget;
+    /** Present only when the target has a spawn journal. */
+    readonly journal: RunContextSnapshot | null;
+    readonly spans: readonly SpanRunSnapshot[];
+    /** True once every present source says the run is over. */
+    readonly terminal: boolean;
+}
+declare function readRunWatchSnapshot(target: RunWatchTarget): Promise<RunWatchSnapshot>;
+declare function renderRunWatchSnapshot(snapshot: RunWatchSnapshot): string;
+interface WatchRunTargetOptions {
+    /** Print one snapshot and return — what a script or an agent wants. */
+    readonly once?: boolean;
+    /** Poll period in ms (default 2000). */
+    readonly intervalMs?: number;
+    /** Where to write (default stdout). */
+    readonly write?: (text: string) => void;
+    readonly signal?: AbortSignal;
+    /** Keep tailing after the run reaches a terminal state (default: stop). */
+    readonly follow?: boolean;
+}
+/**
+ * Tail a target until every source says the run is over. Prints a block only
+ * when the rendered view changed, so the last thing on screen is always the
+ * last thing that happened.
+ */
+declare function watchRunTarget(target: RunWatchTarget, opts?: WatchRunTargetOptions): Promise<RunWatchSnapshot>;
+
 /**
  * Privacy redaction for trace spans before upload.
  *
@@ -2212,4 +2720,4 @@ interface ExecuteOptions {
 /** Send the final, new outbound items (or write their dry-run OTLP). */
 declare function executeUpload(plan: UploadPlan, opts?: ExecuteOptions): Promise<UploadResult>;
 
-export { ACTOR_ATTR, ATTR, type Actor, type AdoptionOptions, type AdoptionReport, AmpAdapter, type AnalyzeOptions, type AnalyzeResult, type BuildPolicyEvidenceOptions, type BuildSessionIndexOptions, type BuildTraceFindingPacketOptions, CODING_REDACTION_RULES, CONTENT_CAP, CORRECTIVE_REACTIONS, type ChatTrajectory, type ChatTrajectoryMessage, type ChatTrajectoryOptions, ClaudeAdapter, type CodeTraceBenchFileRef, type CodeTraceBenchImportOptions, type CodeTraceBenchImportReceipt, type CodeTraceBenchImportResult, type CodeTraceBenchImportedTrace, type CodeTraceBenchStep, CodexAdapter, CodexExecAdapter, CodexExecStreamError, CodexTaskScopeError, type CollectOptions, type CollectPolicyEvidenceOptions, type CollectSessionIndexOptions, type CollectSessionSelectionOptions, type CollectSessionWorkflowOptions, CopilotAdapter, type CorruptionMode, DEFAULT_HARNESS, EmptySessionError, type ExecuteOptions, type ExternalAnalysisKind, type ExternalAnalysisPayload, type ExternalAnalysisResult, type ExternalAnalyzer, type ExternalAnalyzerOptions, type ExternalDiscoveryCandidate, FactoryAdapter, ForgeAdapter, GeminiAdapter, type HaloAnalyzerOptions, type HaloReasoningEffort, type HarnessTraceAdapter, type HodoscopeAnalyzerOptions, type HodoscopeInput, type HodoscopeMessage, type HodoscopeSourceMapEntry, type HodoscopeTrajectory, INGEST_SOURCE_CLI, type InspectSessionIndexOptions, JsonSourceError, type JsonlCorruptionReceipt, JsonlParseError, type JsonlReadOptions, type LiveBatchOptions, type LocateOptions, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpSpan, type OtlpSpanKind, type OtlpStatusCode, type ParentTaskResolution, type ParseOptions, PartialUploadError, PiAdapter, type PipelineOptions, type PipelineReport, type PlanOptions, type PolicyEvidenceLoopSummary, type PolicyEvidenceRecord, type PolicyEvidenceToolSummary, QwenAdapter, REACTIONS, type Reaction, type ReactionReport, type ReactionSessionReport, type Redactor, type RepoAttrs, type RepoResolution, type RepoResolutionSource, type RunResult, type RuntimeTrace, type ScanOptions, type ScannedSession, type SessionBatch, type SessionCorruptionReceipt, type SessionIdentityConflict, type SessionIdentityIndex, type SessionIntegrity, type SessionRef, type SessionRelationship, type SessionRole, type SessionSeedGroup, type SessionSelection, type SessionSelectionRow, type SessionSourceFile, type SessionWorkflow, SessionWorkflowError, type SessionWorkflowErrorCode, type SessionWorkflowIssue, type SessionWorkflowSession, type SessionWorkflowSummary, type SpanInput, type SpanRedaction, TRACES_REDACTION_RULES, type TraceAgenticRoute, type TraceAgenticRouteReason, type TraceAgenticRouteReasonCode, type TraceContextIndex, type TraceContextRoot, type TraceEvidenceExportOptions, type TraceEvidenceExportResult, type TraceEvidenceFormatOption, type TraceEvidenceInputFormat, type TraceEvidenceRow, type TraceExecutionOptions, type TraceFindingPacket, type TraceImprovementArtifacts, type TraceImprovementOptions, type TraceImprovementResult, type TraceIndexedFile, type TraceInspectionArea, type TraceInspectionFinding, type TraceInspectionReport, type TraceInspectionSeverity, type TraceInvestigationOptions, type TraceInvestigationResult, type TraceLiveAction, type TraceLiveActionKind, type TraceLiveAnalysisContext, type TraceLiveAnalyst, type TraceLiveBatch, type TraceLiveEvidence, type TraceLiveFinding, type TraceLiveLoop, type TraceLiveSeverity, type TraceSessionIndex, type TraceSessionIndexRow, type TraceStoreInvestigationOptions, type TraceStoreInvestigationResult, type TraceStreamEvent, type TraceStreamOptions, type TraceStreamReplayOptions, type TraceStreamSession, type TracesConfig, type TriggerPair, type UploadBackend, type UploadIdentity, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, type UserPromptInput, alreadyUploaded, analyzeAdoption, analyzeLiveBatch, analyzeReactions, analyzeSpans, applyRedactor, buildPolicyEvidenceRecord, buildSessionIndex, buildSessionIndexFromRows, buildTraceFindingPacket, capText, chatTrajectoryToSpans, classifyLiveActions, classifyReaction, claudeActor, codexActor, collectPolicyEvidence, collectSessionIndex, collectSessionSelection, collectSessionWorkflow, collectSessions, commandAnalyzer, commandRedactor, countSkillRunsJsonl, cwdMatchesSelection, defaultTraceLiveAnalysts, describeSessionRelationship, equivalentGitCwds, executeUpload, exportTraceEvidenceFile, exportTraceEvidenceRows, exportTraceEvidenceText, haloAnalyzer, hodoscopeAnalyzer, importCodeTraceBench, indexSessionIdsByTrace, inspectSessionIndex, isChatTrajectory, isChatTrajectoryMessage, knownHarnesses, listAdapters, loadState, loadTracesConfig, locateSessions, looksLikeAgentPrompt, mergeTracesConfig, normalizeRemote, outboundHash, parseIsoToEpochMs, parseSession, parseSince, planTraceAgenticRoute, planUpload, readJsonFile, readJsonl, readSessionIndexFile, recordSessionCorruption, redactSpans, renderInspectionReport, resolveAdapter, resolveRepoAttrs, resolveSessionRepoAttrs, runCommand, runExternalAnalyzers, runPipelines, runTraceImprovement, runTraceInvestigation, runTraceStoreInvestigation, saveReport, saveState, scanSessions, selectAdapters, serializeInspectionReport, serializePolicyEvidence, serializeSessionIndex, serializeSpans, serializeTraceStreamEvent, sessionHash, sessionIdFromAttributes, sessionIntegrityAttributes, span, stampRepoAttrs, stampSessionIdentity, stampSessionIntegrity, stampSpanWorkdirRepoAttrs, streamSessions, summarizeOtlpExecution, summarizeSpanExecution, takeJsonl, textIsSynthetic, toOpenInferenceSpan, toRuntimeStore, toTraceSpanEvents, totalAgenticFailureMessage, traceAgenticKinds, traceStreamEventsFromSpans, uploadKey, userPromptSpan, validateOtlpSpans, watchSessions, writeHodoscopeInput, writeInspectionReportFile, writeOtlpFile, writePolicyEvidenceFile, writeSessionIndexFile, writeTraceEvidenceExportFile, writeTraceImprovementArtifacts };
+export { ACTOR_ATTR, ATTR, type Actor, type AdoptionOptions, type AdoptionReport, AmpAdapter, type AnalyzeOptions, type AnalyzeResult, BLOBS_DIR, type BuildPolicyEvidenceOptions, type BuildSessionIndexOptions, type BuildTraceFindingPacketOptions, CODING_REDACTION_RULES, CONTENT_CAP, COORDINATION_LOG_FILE, CORRECTIVE_REACTIONS, type ChatTrajectory, type ChatTrajectoryMessage, type ChatTrajectoryOptions, ClaudeAdapter, type CodeTraceBenchFileRef, type CodeTraceBenchImportOptions, type CodeTraceBenchImportReceipt, type CodeTraceBenchImportResult, type CodeTraceBenchImportedTrace, type CodeTraceBenchStep, CodexAdapter, CodexExecAdapter, CodexExecStreamError, CodexTaskScopeError, type CollectOptions, type CollectPolicyEvidenceOptions, type CollectSessionIndexOptions, type CollectSessionSelectionOptions, type CollectSessionWorkflowOptions, type CoordinationLog, type CoordinationQuestion, type CoordinationSteer, CopilotAdapter, type CorruptionMode, DEFAULT_HARNESS, EMPTY_SPAN_RUN_SNAPSHOT, EmptySessionError, type ExecuteOptions, type ExternalAnalysisKind, type ExternalAnalysisPayload, type ExternalAnalysisResult, type ExternalAnalyzer, type ExternalAnalyzerOptions, type ExternalDiscoveryCandidate, FactoryAdapter, type FileRunContextReaderOptions, ForgeAdapter, GeminiAdapter, type HaloAnalyzerOptions, type HaloReasoningEffort, type HarnessTraceAdapter, type HodoscopeAnalyzerOptions, type HodoscopeInput, type HodoscopeMessage, type HodoscopeSourceMapEntry, type HodoscopeTrajectory, INGEST_SOURCE_CLI, type InspectSessionIndexOptions, JsonSourceError, type JsonlCorruptionReceipt, JsonlParseError, type JsonlReadOptions, type LiveBatchOptions, type LocateOptions, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpSpan, type OtlpSpanKind, type OtlpStatusCode, type ParentTaskResolution, type ParseOptions, PartialUploadError, PiAdapter, type PipelineOptions, type PipelineReport, type PlanOptions, type PolicyEvidenceLoopSummary, type PolicyEvidenceRecord, type PolicyEvidenceToolSummary, QwenAdapter, REACTIONS, RESULT_FILE, RULE, type Reaction, type ReactionReport, type ReactionSessionReport, type Redactor, type RepoAttrs, type RepoResolution, type RepoResolutionSource, type RunContextJournal, type RunContextNode, type RunContextResult, type RunContextSnapshot, type RunResult, type RunWatchSnapshot, type RunWatchTarget, type RuntimeTrace, SPAWN_JOURNAL_FILE, STATUS_MARK, type ScanOptions, type ScannedSession, type SessionBatch, type SessionCorruptionReceipt, type SessionIdentityConflict, type SessionIdentityIndex, type SessionIntegrity, type SessionRef, type SessionRelationship, type SessionRole, type SessionSeedGroup, type SessionSelection, type SessionSelectionRow, type SessionSourceFile, type SessionWorkflow, SessionWorkflowError, type SessionWorkflowErrorCode, type SessionWorkflowIssue, type SessionWorkflowSession, type SessionWorkflowSummary, type SpanInput, type SpanNodeStatus, type SpanRedaction, type SpanRunNode, type SpanRunSnapshot, type SpendRoll, TRACES_REDACTION_RULES, type TraceAgenticRoute, type TraceAgenticRouteReason, type TraceAgenticRouteReasonCode, type TraceContextIndex, type TraceContextRoot, type TraceEvidenceExportOptions, type TraceEvidenceExportResult, type TraceEvidenceFormatOption, type TraceEvidenceInputFormat, type TraceEvidenceRow, type TraceExecutionOptions, type TraceFindingPacket, type TraceImprovementArtifacts, type TraceImprovementOptions, type TraceImprovementResult, type TraceIndexedFile, type TraceInspectionArea, type TraceInspectionFinding, type TraceInspectionReport, type TraceInspectionSeverity, type TraceInvestigationOptions, type TraceInvestigationResult, type TraceLiveAction, type TraceLiveActionKind, type TraceLiveAnalysisContext, type TraceLiveAnalyst, type TraceLiveBatch, type TraceLiveEvidence, type TraceLiveFinding, type TraceLiveLoop, type TraceLiveSeverity, type TraceSessionIndex, type TraceSessionIndexRow, type TraceStoreInvestigationOptions, type TraceStoreInvestigationResult, type TraceStreamEvent, type TraceStreamOptions, type TraceStreamReplayOptions, type TraceStreamSession, type TracesConfig, type TriggerPair, type UploadBackend, type UploadIdentity, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, type UserPromptInput, type WatchRunTargetOptions, ZERO_ROLL, addSpend, alreadyUploaded, analyzeAdoption, analyzeLiveBatch, analyzeReactions, analyzeSpans, applyRedactor, buildPolicyEvidenceRecord, buildSessionIndex, buildSessionIndexFromRows, buildSpanRunTree, buildTraceFindingPacket, capText, chatTrajectoryToSpans, classifyLiveActions, classifyReaction, claudeActor, codexActor, collectPolicyEvidence, collectSessionIndex, collectSessionSelection, collectSessionWorkflow, collectSessions, commandAnalyzer, commandRedactor, connectors, countSkillRunsJsonl, cwdMatchesSelection, defaultTraceLiveAnalysts, describeSessionRelationship, equivalentGitCwds, executeUpload, exportTraceEvidenceFile, exportTraceEvidenceRows, exportTraceEvidenceText, fileRunContextSupervisorRunReader, findSpanSourceFiles, forEachTreeNode, haloAnalyzer, hodoscopeAnalyzer, importCodeTraceBench, indexSessionIdsByTrace, inferRole, inspectSessionIndex, int, isChatTrajectory, isChatTrajectoryMessage, isFileRunContextDir, knownHarnesses, listAdapters, loadState, loadTracesConfig, locateSessions, looksLikeAgentPrompt, mergeRolls, mergeTracesConfig, ms, normalizeRemote, outboundHash, parseIsoToEpochMs, parseSession, parseSince, planTraceAgenticRoute, planUpload, readCoordinationLog, readFileRunContext, readJsonFile, readJsonl, readRunContextJournal, readRunContextSnapshot, readRunWatchSnapshot, readSessionIndexFile, readSpanRunSnapshot, recordSessionCorruption, redactSpans, renderInspectionReport, renderRunContextSnapshot, renderRunWatchSnapshot, renderSpanRunSnapshot, resolveAdapter, resolveRepoAttrs, resolveRunContextDir, resolveRunWatchTarget, resolveSessionRepoAttrs, runCommand, runExternalAnalyzers, runPipelines, runTotals, runTraceImprovement, runTraceInvestigation, runTraceStoreInvestigation, saveReport, saveState, scanSessions, selectAdapters, serializeInspectionReport, serializePolicyEvidence, serializeSessionIndex, serializeSpans, serializeTraceStreamEvent, sessionHash, sessionIdFromAttributes, sessionIntegrityAttributes, span, spanRunTotals, stampRepoAttrs, stampSessionIdentity, stampSessionIntegrity, stampSpanWorkdirRepoAttrs, streamSessions, summarizeOtlpExecution, summarizeSpanExecution, takeJsonl, textIsSynthetic, toOpenInferenceSpan, toRuntimeStore, toTraceSpanEvents, tokens, totalAgenticFailureMessage, traceAgenticKinds, traceStreamEventsFromSpans, uploadKey, usd, userPromptSpan, validateOtlpSpans, watchRunTarget, watchSessions, wrap, writeHodoscopeInput, writeInspectionReportFile, writeOtlpFile, writePolicyEvidenceFile, writeSessionIndexFile, writeTraceEvidenceExportFile, writeTraceImprovementArtifacts, zeroPricedCost };