@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/index-C61Wi7yg.d.ts

@@ -0,0 +1,547 @@
+import { b as RolloutSplit, 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 {
+  readonly unavailable: string;
+}
+/** A metric value, or the reason it is unknown. NEVER collapse `unavailable` to 0. */
+type Measured<T> = T | Unavailable;
+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. */
+interface WorkerLogSource {
+  readonly label: string;
+  /** Worker event stream — started / progress / finished / message events (JSONL). */
+  readonly events: string | null;
+  /** The durable steer queue — one line per steer request (JSONL). */
+  readonly inbox: string | null;
+  /** Worker patch byte length, or null when absent. */
+  readonly patchBytes: number | null;
+  /** Where this worker's transcript lives, for the rollout row. Null = no such artifact. */
+  readonly transcriptRef?: string | null;
+  /** Where this worker's delivered patch lives. Null = the store keeps no patch per worker. */
+  readonly patchPath?: string | null;
+  /** This worker's own inference tokens, when the store records them per worker. */
+  readonly tokensIn?: number | null;
+  readonly tokensOut?: number | null;
+  readonly cacheRead?: number | null;
+  readonly cacheWrite?: number | null;
+}
+/**
+ * Facts a SOURCE structurally cannot express, each with the reason.
+ *
+ * The difference between "the artifact is missing" and "this store never
+ * records that fact" is the difference between a run that spent $0 and a
+ * harness that does not price inference — and the second harness is where a
+ * loops-shaped assumption becomes a fabricated zero. A reader declares its
+ * limits once; the analyzer reports `unavailable` for everything downstream.
+ *
+ * `null` on a field means the source DOES carry that fact.
+ */
+interface SourceLimits {
+  /** 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). */
+  readonly workerVerdicts: string | null;
+  /** Reason no delivered artifact (patch/diff) is retained per worker (null = retained). */
+  readonly deliverables: string | null;
+}
+/** A source that carries every fact the analyzer can use. */
+declare const NO_SOURCE_LIMITS: SourceLimits;
+/**
+ * Everything the pure analyzer reads — already-read bytes, never paths. Each
+ * field is `null` when its artifact was absent, which is what turns the
+ * dependent metrics into `unavailable` rather than 0.
+ *
+ * This is the whole input contract. Any store that can produce these strings
+ * (an on-disk loops run, an object-store archive, a database, a test fixture)
+ * is a valid source; `loopsSupervisorRunReader` is ONE implementation.
+ */
+interface SupervisorRunSources {
+  /** Stable identity of the run being analyzed (a directory, a run id, a URL). */
+  readonly runRef: string;
+  readonly instanceId: string | null;
+  /** Which arm/variant of a comparison this run is, when the run belongs to one. */
+  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). */
+  readonly journal: string | null;
+  /** Per-brain-call tap (JSONL): finish_reason, completion tokens, requested max tokens. */
+  readonly brainLog: string | null;
+  /** Supervisor state document (JSON). */
+  readonly state: string | null;
+  /** Supervisor progress stream (JSONL). */
+  readonly progress: string | null;
+  /** Per-worker logs; `null` = the worker log store itself was missing. */
+  readonly workers: readonly WorkerLogSource[] | null;
+  /** Why `workers` is null (only set when it is). */
+  readonly workersMissingReason: string | null;
+  /** Run result document (JSON). */
+  readonly result: string | null;
+  /**
+   * Judge verdict document (JSON), or the matching ledger row re-encoded as
+   * one. Runners that write the verdict straight to a ledger leave no judge
+   * document, so the ledger row is the same fact from the same run — not a
+   * substitute measurement.
+   */
+  readonly judge: string | null;
+  /** Where `judge` came from, for the report's provenance line. */
+  readonly judgeSource: string | null;
+  /** Delivered unified-diff patch text. */
+  readonly patch: string | null;
+  /** Outer-driver log (used for the driver's steer verbs + deadline evidence). */
+  readonly driverLog: string | null;
+  /**
+   * Worker tokens recovered from a harness session store; null = store unavailable.
+   * `store` names the store in the report's provenance line (e.g. `opencode`).
+   */
+  readonly harnessWorkerTokens: {
+    store: string;
+    sessions: number;
+    input: number;
+    output: number;
+    /** Cached prompt tokens, when the store counts them separately. */
+    cacheRead?: number;
+    cacheWrite?: number;
+  } | null;
+  readonly harnessMissingReason: string | null;
+  /** What this store structurally cannot record. See `SourceLimits`. */
+  readonly limits: SourceLimits;
+  /**
+   * Where the ROOT invocation's transcript lives. Undefined lets the rollout
+   * minter fall back to the loops layout (`<supRunDir>/journal.jsonl`); any
+   * other store must say, or the row points at a path that never existed.
+   */
+  readonly rootTranscriptRef?: string | null;
+  /**
+   * The `traces` CLI command that covers this run's harness-session layer.
+   * Null falls back to the analyzer's default (an opencode worker fleet).
+   */
+  readonly traceCommand: string | null;
+}
+/**
+ * A source of supervisor-run bytes. Implementations own their storage layout;
+ * the analyzer only ever sees `SupervisorRunSources`.
+ */
+interface SupervisorRunReader {
+  /** Stable identity of what this reader points at (for logs and report labels). */
+  readonly runRef: string;
+  read(): Promise<SupervisorRunSources>;
+}
+declare const SUPERVISOR_RUN_SCHEMA = "tangle.supervisor-run@1";
+declare const SUPERVISOR_RUN_ROLLUP_SCHEMA = "tangle.supervisor-run-rollup@1";
+interface SteerBreakdown {
+  readonly worker: string;
+  /** Steer requests durably queued to this worker's inbox. */
+  readonly queued: number;
+  /** Steers the worker's executor actually accepted (control event `delivered:true`). */
+  readonly delivered: number;
+}
+interface OrchestrationMetrics {
+  readonly workersSpawned: Measured<number>;
+  readonly workersSettled: Measured<number>;
+  readonly workersCancelled: Measured<number>;
+  /** THE HEADLINE: mid-task steers the brain sent to live workers. 0 ≠ unavailable. */
+  readonly steers: Measured<number>;
+  readonly steersDelivered: Measured<number>;
+  readonly steersByWorker: Measured<readonly SteerBreakdown[]>;
+  /** Outer-driver `supervisor_steer` tool calls seen in the driver log (a second steer path). */
+  readonly driverSteerCalls: Measured<number>;
+  /**
+   * Spawn waves. A wave is a maximal run of worker spawns with no settle/cancel between
+   * them: wave N+1 begins at the first spawn issued after at least one worker from an
+   * earlier wave has settled. Structural, not a time threshold — no tunable constant.
+   */
+  readonly waves: Measured<number>;
+  readonly waveSizes: Measured<readonly number[]>;
+  readonly maxConcurrency: Measured<number>;
+  /** Worker spawns issued after the first settlement — the retry/respawn tail. */
+  readonly respawns: Measured<number>;
+  /** Labels spawned more than once (a literal retry of the same subtask). */
+  readonly repeatedLabels: Measured<readonly string[]>;
+  /** Longest parent chain below the root, in worker hops. */
+  readonly delegationDepth: Measured<number>;
+  readonly timeToFirstSpawnMs: Measured<number>;
+  readonly supervisorWallMs: Measured<number>;
+  /** Wall time inside the supervisor run with ZERO live workers. */
+  readonly idleMs: Measured<number>;
+  readonly idlePct: Measured<number>;
+  /** sum(worker wall) / supervisor wall. >1 means real parallelism. */
+  readonly workerUtilization: Measured<number>;
+}
+interface DecisionMetrics {
+  readonly settledByStatus: Measured<Record<string, number>>;
+  readonly settledVerdicts: Measured<Record<string, number>>;
+  /** Worker verified its own work green AND produced a patch. */
+  readonly accepted: Measured<number>;
+  /** Worker settled with a failing verify. */
+  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). */
+  readonly observeThenRespawn: Measured<number>;
+  /** Respawns with no settled evidence 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>;
+  readonly workerEvidenceBytes: Measured<number>;
+}
+interface RoleSpend {
+  readonly tokensIn: Measured<number>;
+  readonly tokensOut: Measured<number>;
+  /**
+   * Cached prompt tokens read/written. On a harness that caches aggressively
+   * these dwarf `tokensIn`, so a report that omits them understates the context
+   * each invocation actually consumed. `unavailable` = the store has no such counter.
+   */
+  readonly cacheRead: Measured<number>;
+  readonly cacheWrite: Measured<number>;
+  readonly usd: Measured<number>;
+  readonly source: string;
+}
+interface PerWorkerRow {
+  readonly worker: string;
+  readonly wallMs: number | null;
+  /** `null` = this store does not attribute tokens per worker (NOT "zero tokens"). */
+  readonly tokensIn: number | null;
+  readonly tokensOut: number | null;
+  readonly usd: number | null;
+  readonly patchBytes: number | null;
+  readonly passed: boolean | null;
+}
+interface WallDistribution {
+  readonly n: number;
+  readonly min: number;
+  readonly p50: number;
+  readonly p90: number;
+  readonly max: number;
+  readonly sum: number;
+}
+interface EconomicsMetrics {
+  /** Driver/brain inference — journal `metered` events. */
+  readonly brain: RoleSpend;
+  /**
+   * Brain completions that came back `finish_reason: "length"` — output TRUNCATED. Any value
+   * above 0 means the supervisor planned into a wall and then acted on the half-written plan,
+   * which is a defect and not a cost figure. The journal's `metered` rows carry token counts
+   * but no finish reason, so this reads the per-call brain tap; a run whose supervisor
+   * predates that tap reports `unavailable`, never 0.
+   */
+  readonly brainTruncations: Measured<number>;
+  /** Worker inference — journal `settled` spend plus the harness session join. */
+  readonly workers: RoleSpend;
+  readonly totalUsd: Measured<number>;
+  /**
+   * Where `totalUsd` came from. CLI-backend workers never price their own inference into
+   * the journal, so on those arms the total is BRAIN-ONLY and the worker row's token
+   * counts (recovered from the harness store) are the honest worker-side figure.
+   */
+  readonly totalUsdSource: string;
+  readonly costPerAcceptedPatchUsd: Measured<number>;
+  readonly workerWallMsDistribution: Measured<WallDistribution>;
+  readonly perWorker: Measured<readonly PerWorkerRow[]>;
+}
+interface PatchStats {
+  readonly files: number;
+  readonly linesAdded: number;
+  readonly linesRemoved: number;
+  readonly testFilesTouched: readonly string[];
+}
+interface OutcomeMetrics {
+  readonly supStatus: Measured<string>;
+  readonly supVerdict: Measured<string>;
+  readonly delivered: Measured<boolean>;
+  readonly judgeResolved: Measured<boolean | null>;
+  readonly judgeScore: Measured<number | null>;
+  readonly judgePassed: Measured<number | null>;
+  readonly judgeTotal: Measured<number | null>;
+  readonly verifyPass: Measured<boolean>;
+  readonly verifyRc: Measured<number>;
+  readonly patch: Measured<PatchStats>;
+  /** Which document the judge fields came from (a judge file, a ledger row, or nothing). */
+  readonly judgeSource: string | null;
+}
+interface SupervisorRunReport {
+  readonly schema: typeof SUPERVISOR_RUN_SCHEMA;
+  /** The `runRef` of the sources this report was computed from. */
+  readonly runRef: string;
+  readonly instanceId: string | null;
+  readonly arm: string | null;
+  readonly supervisorId: Measured<string>;
+  readonly generatedAt: string;
+  readonly orchestration: OrchestrationMetrics;
+  readonly decision: DecisionMetrics;
+  readonly economics: EconomicsMetrics;
+  readonly outcome: OutcomeMetrics;
+  /** Artifacts that were missing, in read order — the provenance of every `unavailable`. */
+  readonly gaps: readonly string[];
+  /** The `traces` CLI command that covers the harness-session layer for this run. */
+  readonly traceCommand: string;
+}
+interface RollupCellRow {
+  readonly instanceId: string | null;
+  readonly arm: string | null;
+  readonly steers: Measured<number>;
+  readonly waves: Measured<number>;
+  readonly utilization: Measured<number>;
+  readonly idlePct: Measured<number>;
+  readonly resolved: Measured<boolean | null>;
+  readonly usd: Measured<number>;
+}
+interface SupervisorRunRollup {
+  readonly schema: typeof SUPERVISOR_RUN_ROLLUP_SCHEMA;
+  readonly cells: number;
+  readonly steersTotal: Measured<number>;
+  readonly cellsWithSteers: Measured<number>;
+  readonly cellsWithUnavailableSteers: number;
+  readonly wavesMean: Measured<number>;
+  readonly maxConcurrencyMax: Measured<number>;
+  readonly utilizationMean: Measured<number>;
+  readonly idlePctMean: Measured<number>;
+  readonly workersSpawnedTotal: Measured<number>;
+  readonly acceptedTotal: Measured<number>;
+  readonly usdTotal: Measured<number>;
+  readonly resolvedCount: Measured<number>;
+  readonly perCell: readonly RollupCellRow[];
+}
+/**
+ * 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.
+ */
+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[];
+}
+/**
+ * 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;
+}
+/**
+ * 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

package/dist/index-C61Wi7yg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-C61Wi7yg.d.ts","names":[],"sources":["../src/supervisor-run/types.ts","../src/supervisor-run/analyze.ts","../src/supervisor-run/claude-code-reader.ts","../src/supervisor-run/loops-reader.ts","../src/supervisor-run/render.ts","../src/supervisor-run/rollout-nodes.ts"],"mappings":"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"}