@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/supervisor-run/index.d.ts

@@ -1,5 +1,184 @@
 import { b as RolloutSplit } from "../schema-C-ziyJD7.js";
-import { A as WallDistribution, C as SupervisorRunSources, D as SupervisorStatusSource, E as SupervisorRunTreeGapCode, F as showMeasured, I as unavailable, M as WorkerNativeSession, N as WorkerTurnCoverage, O as TerminalFailure, P as isUnavailable, S as SupervisorRunRollup, T as SupervisorRunTreeGap, _ as SpendMeasurements, a as NamedResourceReceipt, b as SupervisorRunReader, c as PatchStats, d as RoleSpend, f as RollupCellRow, g as SpendMeasurement, h as SourceLimits, i as NO_SOURCE_LIMITS, j as WorkerLogSource, k as Unavailable, l as PerWorkerRow, m as SUPERVISOR_RUN_SCHEMA, n as EconomicsMetrics, o as OrchestrationMetrics, p as SUPERVISOR_RUN_ROLLUP_SCHEMA, r as Measured, s as OutcomeMetrics, t as DecisionMetrics, u as ResourceSpendRecord, v as SteerBreakdown, w as SupervisorRunTree, x as SupervisorRunReport, y as SupervisorRunNodeRole } from "../types-BqkVmHfv.js";
+import { A as WorkerTurnCoverage, C as SupervisorRunTreeGapCode, D as WallDistribution, E as Unavailable, M as showMeasured, N as unavailable, O as WorkerLogSource, S as SupervisorRunTreeGap, T as TerminalFailure, _ as SupervisorRunReader, a as OrchestrationMetrics, b as SupervisorRunSources, c as PerWorkerRow, d as RollupCellRow, f as SourceLimits, g as SupervisorRunNodeRole, h as SteerBreakdown, i as NamedResourceReceipt, j as isUnavailable, k as WorkerNativeSession, l as ResourceSpendRecord, m as SpendMeasurements, n as EconomicsMetrics, o as OutcomeMetrics, p as SpendMeasurement, r as Measured, s as PatchStats, t as DecisionMetrics, u as RoleSpend, v as SupervisorRunReport, w as SupervisorStatusSource, x as SupervisorRunTree, y as SupervisorRunRollup } from "../types-CmXY0PQf.js";
+//#region src/supervisor-run/analyze.d.ts
+/**
+ * Analyze already-read supervisor-run bytes. Pure and synchronous: same bytes
+ * in, same report out (modulo `generatedAt`, which `now` pins in tests).
+ */
+export declare function analyzeSupervisorRunSources(src: SupervisorRunSources, now?: () => number): SupervisorRunReport;
+//#endregion
+//#region src/supervisor-run/claude-code-reader.d.ts
+/**
+ * Supervision-tree reader over a THIRD-PARTY harness: Claude Code.
+ *
+ * The Runtime reader reads a supervisor journal designed for this analysis.
+ * for this analysis. This reader reads a harness we do not control, whose
+ * transcript was designed for replaying a chat — and recovers the same tree
+ * from it. If both produce a `SupervisorRunSources`, the tree model is a
+ * property of multi-agent runs, not of our journal format.
+ *
+ * ## Where the tree hides in a Claude Code transcript
+ *
+ * | Tree fact | Claude Code evidence |
+ * |---|---|
+ * | spawn      | assistant `tool_use` (`Agent` / `Task`), answered by a `tool_result` whose `toolUseResult.agentId` names the child |
+ * | settle     | a `<task-notification>` block in a later user line: `<task-id>` = agentId, `<status>` |
+ * | steer      | assistant `tool_use` (`SendMessage`) with `input.to` = agentId — mid-task, to a LIVE child |
+ * | delivered  | that steer's `tool_result` carrying `success` / `resumedAgentId` |
+ * | cancel     | assistant `tool_use` (`TaskStop`) targeting an agentId |
+ * | brain spend| `message.usage` on the main thread's assistant lines |
+ * | worker spend| `message.usage` inside `<session>/subagents/agent-<id>.jsonl` |
+ * | depth      | a child transcript that itself contains `Agent` tool_use lines |
+ *
+ * Every one of those is read from the normalized session of @tangle-network/harness-sessions — the SAME
+ * parser `src/rollout/readers/claude-jsonl.ts` uses for solo rollouts. There
+ * is no second transcript parser.
+ *
+ * ## What Claude Code cannot say
+ *
+ * It records tokens but never a price, runs no per-worker verify, and keeps no
+ * per-worker patch. Those are declared once in `limits`, so the analyzer
+ * reports `unavailable — <reason>` instead of the $0 / 0-accepted that summing
+ * an empty field would produce. See `SourceLimits`.
+ *
+ * ## Metric coverage vs the Runtime journal
+ *
+ * Measured on a real 52-agent session (fixture:
+ * `tests/fixtures/supervisor-run/claude-code-session-*`).
+ *
+ * | Metric | Runtime | Claude Code | Why |
+ * |---|---|---|---|
+ * | workersSpawned / Settled / Cancelled | full | full | spawn tool_use + task-notification + TaskStop |
+ * | steers / steersDelivered / steersByWorker | full | full | `SendMessage`; delivery from its tool_result |
+ * | waves / waveSizes / maxConcurrency | full | full | derived from spawn/settle instants |
+ * | respawns / repeatedLabels | full | full | same derivation |
+ * | delegationDepth | full | full | a child transcript's own spawn calls |
+ * | timeToFirstSpawn / supervisorWall | full | full | transcript instants |
+ * | idleMs / idlePct / workerUtilization | full | PARTIAL | an agent that never notifies is counted live to the end of the transcript |
+ * | observeThenRespawn / respawnWithoutEvidence | full | full | ordering of spawn vs settle instants |
+ * | workerEvidenceBytes | full | PARTIAL | the child's closing message; 0 for pruned transcripts |
+ * | brain tokens in/out + cache | full | full | main-thread `message.usage` |
+ * | worker tokens in/out + cache | via harness join | full or unavailable | totals are refused if any spawned transcript was pruned; retained per-worker rows remain available |
+ * | perWorker wall | full | full | spawn → settle instants |
+ * | accepted / rejected / emptyPass / settledVerdicts | full | NONE | no per-worker verify step exists |
+ * | brain/worker/total usd, costPerAcceptedPatch | full | NONE | transcripts carry no price |
+ * | patch stats, delivered, verifyPass/Rc | full | NONE | no diff is handed back |
+ * | judgeResolved / Score / Passed / Total | full | NONE | no judge in the loop |
+ * | driverSteerCalls, brainTruncations | full | NONE | no outer driver log, no per-call finish_reason tap |
+ */
+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[];
+}
+//#endregion
+//#region src/supervisor-run/integrity-types.d.ts
+export declare const SUPERVISOR_RUN_INTEGRITY_SCHEMA = "tangle.supervisor-run-integrity@1";
+type SupervisorRunIntegritySeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+type SupervisorRunSourceOnlyCheckCode = 'journal-event-cardinality' | 'worker-control-join' | 'steer-ack-correlation';
+type SupervisorRunIntegrityIssueCode = 'source-checks-unavailable' | 'node-schema-invalid' | 'node-checks-unavailable' | 'root-unavailable' | 'duplicate-rollout-id' | 'declared-root-missing' | 'root-has-parent' | 'root-role-invalid' | 'detached-node' | 'parent-missing' | 'cross-run-parent' | 'child-before-parent' | 'child-after-parent-close' | 'close-before-start' | 'parent-cycle' | 'child-terminal-unavailable' | 'transcript-unavailable' | 'transcript-incomplete' | 'native-session-unavailable' | 'profile-id-unavailable' | 'source-row-malformed' | 'source-event-identity-unavailable' | 'duplicate-spawn' | 'orphan-terminal' | 'duplicate-terminal' | 'worker-controls-unavailable' | 'worker-control-join-unavailable' | 'steer-request-id-unavailable' | 'steer-ack-id-unavailable' | 'steer-ack-status-unavailable' | 'duplicate-steer-request-id' | 'missing-steer-ack' | 'duplicate-steer-ack' | 'unknown-steer-ack' | 'steer-not-delivered';
+interface SupervisorRunIntegrityEvidence {
+  readonly path: string;
+  readonly value: unknown;
+}
+interface SupervisorRunIntegrityIssue {
+  readonly code: SupervisorRunIntegrityIssueCode;
+  readonly area: 'control-integrity' | 'capture-integrity';
+  readonly severity: SupervisorRunIntegritySeverity;
+  readonly subject: string;
+  readonly claim: string;
+  readonly detail: string;
+  readonly evidence: readonly SupervisorRunIntegrityEvidence[];
+  readonly recommendedAction: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface SupervisorRunIntegrityReport {
+  readonly schema: typeof SUPERVISOR_RUN_INTEGRITY_SCHEMA;
+  readonly runRef: string;
+  readonly input: 'sources' | 'tree';
+  readonly tree: SupervisorRunTree;
+  readonly issues: readonly SupervisorRunIntegrityIssue[];
+}
+interface SupervisorRunIntegrityOptions {
+  /** Pins rollout provenance when source input must be projected into a tree. */
+  readonly capturedAt?: string;
+}
+//#endregion
+//#region src/supervisor-run/integrity.d.ts
+/**
+ * Run deterministic integrity checks over source bytes or an already minted tree.
+ * Source input is parsed exactly once and reused by projection and source-only checks.
+ */
+export declare function analyzeSupervisorRunIntegrity(input: SupervisorRunSources | SupervisorRunTree, options?: SupervisorRunIntegrityOptions): SupervisorRunIntegrityReport;
+//#endregion
+//#region src/supervisor-run/patch-stats.d.ts
+/** Unified-diff stats. Counts `+++ b/<path>` targets, body +/- lines, and test-file touches. */
+export declare function parsePatch(text: string): PatchStats;
+//#endregion
+//#region src/supervisor-run/reader.d.ts
+/**
+ * Analyze a supervisor run. Accepts a Runtime run directory, any
+ * `SupervisorRunReader`, or already-read source bytes — so a
+ * caller with its own store never has to touch the filesystem layout.
+ */
+export declare function analyzeSupervisorRun(input: string | SupervisorRunReader | SupervisorRunSources): Promise<SupervisorRunReport>;
+interface WriteSupervisorRunOptions {
+  /** 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;
+}
+/**
+ * Every Runtime supervisor run below `root`.
+ *
+ * When `root` itself is one run, return no children so callers can distinguish
+ * a single report from a parent-directory rollup.
+ */
+export 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.
+ */
+export declare function renderSupervisorRunHeadline(r: SupervisorRunReport): string;
+export declare function renderSupervisorRunMarkdown(r: SupervisorRunReport): string;
+export declare function renderSupervisorRollupMarkdown(rollup: SupervisorRunRollup, title?: string): string;
+//#endregion
+//#region src/supervisor-run/report-command.d.ts
+/**
+ * `agent-eval supervisor-run report <runDir>` takes one run directory and
+ * prints the report the module already renders. The command reads through
+ * `analyzeSupervisorRun`, so a Runtime run directory takes the
+ * same path and the status comes from the record `terminal-record.ts` names.
+ *
+ * Exit codes follow the other self-parsing subcommands: 2 for a usage error,
+ * 1 when the directory cannot be read (missing, not a directory, or a corrupt
+ * journal or terminal record), 0 after the report was written to stdout.
+ */
+type SupervisorRunReportFormat = 'headline' | 'markdown' | 'json';
+/** Output sinks, injectable so tests read the exact bytes a terminal would. */
+interface SupervisorRunCommandIo {
+  readonly stdout: (text: string) => void;
+  readonly stderr: (text: string) => void;
+}
+//#endregion
 //#region src/supervisor-run/source-facts.d.ts
 interface Tokens {
   input: number;
@@ -211,155 +390,6 @@ interface SupervisorTreeFacts {
 type SupervisorJournalDialect = 'none' | 'flat' | 'runtime-envelope' | 'mixed';
 export declare function parseSupervisorTree(src: SupervisorRunSources): SupervisorTreeFacts;
 //#endregion
-//#region src/supervisor-run/analyze.d.ts
-/**
- * Analyze already-read supervisor-run bytes. Pure and synchronous: same bytes
- * in, same report out (modulo `generatedAt`, which `now` pins in tests).
- */
-export declare function analyzeSupervisorRunSources(src: SupervisorRunSources, now?: () => number): SupervisorRunReport;
-/** Unified-diff stats. Counts `+++ b/<path>` targets, body +/- lines, and test-file touches. */
-export 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.
- */
-export declare function rollupSupervisorRuns(reports: readonly SupervisorRunReport[]): SupervisorRunRollup;
-//#endregion
-//#region src/supervisor-run/claude-code-reader.d.ts
-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.
- */
-export declare function readClaudeCodeSupervisorRun(opts: ClaudeCodeReaderOptions): Promise<SupervisorRunSources>;
-/** A `SupervisorRunReader` over a Claude Code session — the same contract Runtime implements. */
-export declare function claudeCodeSupervisorRunReader(opts: ClaudeCodeReaderOptions): SupervisorRunReader;
-//#endregion
-//#region src/supervisor-run/integrity-types.d.ts
-export declare const SUPERVISOR_RUN_INTEGRITY_SCHEMA = "tangle.supervisor-run-integrity@1";
-type SupervisorRunIntegritySeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
-type SupervisorRunSourceOnlyCheckCode = 'journal-event-cardinality' | 'worker-control-join' | 'steer-ack-correlation';
-type SupervisorRunIntegrityIssueCode = 'source-checks-unavailable' | 'node-schema-invalid' | 'node-checks-unavailable' | 'root-unavailable' | 'duplicate-rollout-id' | 'declared-root-missing' | 'root-has-parent' | 'root-role-invalid' | 'detached-node' | 'parent-missing' | 'cross-run-parent' | 'child-before-parent' | 'child-after-parent-close' | 'close-before-start' | 'parent-cycle' | 'child-terminal-unavailable' | 'transcript-unavailable' | 'transcript-incomplete' | 'native-session-unavailable' | 'profile-id-unavailable' | 'source-row-malformed' | 'source-event-identity-unavailable' | 'duplicate-spawn' | 'orphan-terminal' | 'duplicate-terminal' | 'worker-controls-unavailable' | 'worker-control-join-unavailable' | 'steer-request-id-unavailable' | 'steer-ack-id-unavailable' | 'steer-ack-status-unavailable' | 'duplicate-steer-request-id' | 'missing-steer-ack' | 'duplicate-steer-ack' | 'unknown-steer-ack' | 'steer-not-delivered';
-interface SupervisorRunIntegrityEvidence {
-  readonly path: string;
-  readonly value: unknown;
-}
-interface SupervisorRunIntegrityIssue {
-  readonly code: SupervisorRunIntegrityIssueCode;
-  readonly area: 'control-integrity' | 'capture-integrity';
-  readonly severity: SupervisorRunIntegritySeverity;
-  readonly subject: string;
-  readonly claim: string;
-  readonly detail: string;
-  readonly evidence: readonly SupervisorRunIntegrityEvidence[];
-  readonly recommendedAction: string;
-  readonly metadata?: Readonly<Record<string, unknown>>;
-}
-interface SupervisorRunIntegrityReport {
-  readonly schema: typeof SUPERVISOR_RUN_INTEGRITY_SCHEMA;
-  readonly runRef: string;
-  readonly input: 'sources' | 'tree';
-  readonly tree: SupervisorRunTree;
-  readonly issues: readonly SupervisorRunIntegrityIssue[];
-}
-interface SupervisorRunIntegrityOptions {
-  /** Pins rollout provenance when source input must be projected into a tree. */
-  readonly capturedAt?: string;
-}
-//#endregion
-//#region src/supervisor-run/integrity.d.ts
-/**
- * Run deterministic integrity checks over source bytes or an already minted tree.
- * Source input is parsed exactly once and reused by projection and source-only checks.
- */
-export declare function analyzeSupervisorRunIntegrity(input: SupervisorRunSources | SupervisorRunTree, options?: SupervisorRunIntegrityOptions): SupervisorRunIntegrityReport;
-//#endregion
-//#region src/supervisor-run/reader.d.ts
-/**
- * Analyze a supervisor run. Accepts a Runtime run directory, any
- * `SupervisorRunReader`, or already-read source bytes — so a
- * caller with its own store never has to touch the filesystem layout.
- */
-export declare function analyzeSupervisorRun(input: string | SupervisorRunReader | SupervisorRunSources): Promise<SupervisorRunReport>;
-interface WriteSupervisorRunOptions {
-  /** 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.
- */
-export declare function writeSupervisorRunReport(runDir: string, opts?: WriteSupervisorRunOptions): Promise<SupervisorRunReport>;
-/**
- * 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.
- */
-export declare function writeSupervisorRunReportSafe(runDir: string, opts?: WriteSupervisorRunOptions): Promise<SupervisorRunReport | null>;
-/**
- * Every Runtime supervisor run below `root`.
- *
- * When `root` itself is one run, return no children so callers can distinguish
- * a single report from a parent-directory rollup.
- */
-export 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.
- */
-export declare function renderSupervisorRunHeadline(r: SupervisorRunReport): string;
-export declare function renderSupervisorRunMarkdown(r: SupervisorRunReport): string;
-export declare function renderSupervisorRollupMarkdown(rollup: SupervisorRunRollup, title?: string): string;
-//#endregion
-//#region src/supervisor-run/report-command.d.ts
-/**
- * `agent-eval supervisor-run report <runDir>` takes one run directory and
- * prints the report the module already renders. The command reads through
- * `analyzeSupervisorRun`, so a Runtime run directory takes the
- * same path and the status comes from the record `terminal-record.ts` names.
- *
- * Exit codes follow the other self-parsing subcommands: 2 for a usage error,
- * 1 when the directory cannot be read (missing, not a directory, or a corrupt
- * journal or terminal record), 0 after the report was written to stdout.
- */
-type SupervisorRunReportFormat = 'headline' | 'markdown' | 'json';
-/** Output sinks, injectable so tests read the exact bytes a terminal would. */
-interface SupervisorRunCommandIo {
-  readonly stdout: (text: string) => void;
-  readonly stderr: (text: string) => void;
-}
-/**
- * CLI driver for `agent-eval supervisor-run`. `argv` is everything after the
- * command name, so `['report', runDir, ...flags]`. Returns the process exit code.
- */
-export declare function runSupervisorRunCommand(argv: readonly string[], io?: SupervisorRunCommandIo): Promise<number>;
-//#endregion
 //#region src/supervisor-run/rollout-nodes.d.ts
 interface SupervisorRolloutOptions {
   /** Benchmark/suite id for `task.suite`. Defaults to `'supervisor-run'`. */
@@ -394,6 +424,14 @@ interface SupervisorRolloutOptions {
  */
 export declare function supervisorRunRolloutLines(src: SupervisorRunSources, opts?: SupervisorRolloutOptions): SupervisorRunTree;
 //#endregion
+//#region src/supervisor-run/rollup.d.ts
+/**
+ * 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.
+ */
+export declare function rollupSupervisorRuns(reports: readonly SupervisorRunReport[]): SupervisorRunRollup;
+//#endregion
 //#region src/supervisor-run/runtime-reader.d.ts
 interface RuntimeReaderOptions {
   /**
@@ -421,8 +459,6 @@ interface RuntimeReaderOptions {
  * verdict.
  */
 export declare function readRuntimeSupervisorRun(runDir: string, opts?: RuntimeReaderOptions): Promise<SupervisorRunSources>;
-/** The agent-runtime file-backed layout as a `SupervisorRunReader`. */
-export declare function runtimeSupervisorRunReader(runDir: string, opts?: RuntimeReaderOptions): SupervisorRunReader;
 /**
  * True when a directory holds any file only Runtime's durable layer writes:
  * the spawn journal, the observer journal, or the failure record. A run that
@@ -464,5 +500,5 @@ interface TerminalRecord {
 }
 export declare function readTerminalRecord(input: TerminalRecordInput): TerminalRecord;
 //#endregion
-export { type ClaudeCodeReaderOptions, type CloseRow, type DecisionMetrics, type EconomicsMetrics, type Measured, NO_SOURCE_LIMITS, type NamedResourceReceipt, type OrchestrationMetrics, type OutcomeMetrics, type PatchStats, type PerWorkerRow, type ResourceSpendRecord, type RoleSpend, type RollupCellRow, type RuntimeReaderOptions, SUPERVISOR_RUN_ROLLUP_SCHEMA, SUPERVISOR_RUN_SCHEMA, type SourceLimits, type SpawnRow, type SpendMeasurement, type SpendMeasurements, type SteerAcknowledgementFact, type SteerBreakdown, type SteerRequestFact, type SupervisorJournalDialect, type SupervisorRolloutOptions, type SupervisorRunCommandIo, type SupervisorRunIntegrityEvidence, type SupervisorRunIntegrityIssue, type SupervisorRunIntegrityIssueCode, type SupervisorRunIntegrityOptions, type SupervisorRunIntegrityReport, type SupervisorRunIntegritySeverity, type SupervisorRunNodeRole, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunReportFormat, type SupervisorRunRollup, type SupervisorRunSourceOnlyCheckCode, type SupervisorRunSources, type SupervisorRunTree, type SupervisorRunTreeGap, type SupervisorRunTreeGapCode, type SupervisorStatusSource, type SupervisorTreeFacts, type TerminalFailure, type TerminalRecord, type TerminalRecordInput, type Unavailable, type WallDistribution, type WorkerLogFacts, type WorkerLogSource, type WorkerNativeSession, type WorkerTurnCoverage, type WriteSupervisorRunOptions, isUnavailable, showMeasured, unavailable };
+export { type ClaudeCodeReaderOptions, type CloseRow, type DecisionMetrics, type EconomicsMetrics, type Measured, type NamedResourceReceipt, type OrchestrationMetrics, type OutcomeMetrics, type PatchStats, type PerWorkerRow, type ResourceSpendRecord, type RoleSpend, type RollupCellRow, type RuntimeReaderOptions, type SourceLimits, type SpawnRow, type SpendMeasurement, type SpendMeasurements, type SteerAcknowledgementFact, type SteerBreakdown, type SteerRequestFact, type SupervisorJournalDialect, type SupervisorRolloutOptions, type SupervisorRunCommandIo, type SupervisorRunIntegrityEvidence, type SupervisorRunIntegrityIssue, type SupervisorRunIntegrityIssueCode, type SupervisorRunIntegrityOptions, type SupervisorRunIntegrityReport, type SupervisorRunIntegritySeverity, type SupervisorRunNodeRole, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunReportFormat, type SupervisorRunRollup, type SupervisorRunSourceOnlyCheckCode, type SupervisorRunSources, type SupervisorRunTree, type SupervisorRunTreeGap, type SupervisorRunTreeGapCode, type SupervisorStatusSource, type SupervisorTreeFacts, type TerminalFailure, type TerminalRecord, type TerminalRecordInput, type Unavailable, type WallDistribution, type WorkerLogFacts, type WorkerLogSource, type WorkerNativeSession, type WorkerTurnCoverage, type WriteSupervisorRunOptions, isUnavailable, showMeasured, unavailable };
 //# sourceMappingURL=index.d.ts.map

package/dist/supervisor-run/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/supervisor-run/source-facts.ts","../../src/supervisor-run/analyze.ts","../../src/supervisor-run/claude-code-reader.ts","../../src/supervisor-run/integrity-types.ts","../../src/supervisor-run/integrity.ts","../../src/supervisor-run/reader.ts","../../src/supervisor-run/render.ts","../../src/supervisor-run/report-command.ts","../../src/supervisor-run/rollout-nodes.ts","../../src/supervisor-run/runtime-reader.ts","../../src/supervisor-run/terminal-record.ts"],"mappings":";;;UA+BU;EACR;EACA;EACA;EACA;;EAEA;;;;;;EAMA;;UAGe;WACN,YAAY,kBAAkB;EACvC,QAAQ;;;;;;EAMR;EACA;;;;;;EAMA;;UA6Ge;;EAEf;EACA;EACA;EACA;;EAEA,MAAM;;EAEN;;EAEA;EACA;;EAEA;EACA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,OAAO;;EAEP;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA,eAAe;EACf,uBAAuB;;UAGR;;EAEf;EACA;;UAGe;;EAEf;;EAEA;EACA;;;;;;UAOe;WACN,2BAA2B;WAC3B;WACA,iBAAiB;WACjB,iBAAiB;WACjB,uBAAuB;WACvB,uBAAuB;WACvB;;;;;;;IAOP;IACA;IACA;IACA;;IAEA;;IAEA;;IAEA;IACA;;IAEA;;IAEA;IACA;;IAEA;;WAEO,YAAY,oBAAoB;;WAEhC,wBAAwB;;WAExB;;;;;;;;;WASA;;WAEA;;;;;;WAMA,0BAA0B,SAAS;;;;;;;WAOnC;;WAEA,gBAAgB;;WAEhB,OAAO;WACP;WACA;;;;;;WAMA;WACA;;;;;;;;;;;;;;;;;;KAmDC;wBAiFI,oBAAoB,KAAK,uBAAuB;;;;;;;wBChZhD,4BACd,KAAK,sBACL,qBACC;;wBAu4Ba,WAAW,eAAe;;;;;;wBA+C1B,qBAAqB,kBAAkB,wBAAwB;;;UCv6B9D;;WAEN;;;;;WAKA;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;wBAoMW,4BACpB,MAAM,0BACL,QAAQ;;wBAuVK,8BAA8B,MAAM,0BAA0B;;;qBC3nBjE;KAED;KAEA;KAKA;UAqCK;WACN;WACA;;UAGM;WACN,MAAM;WACN;WACA,UAAU;WACV;WACA;WACA;WACA,mBAAmB;WACnB;WACA,WAAW,SAAS;;UAGd;WACN,eAAe;WACf;WACA;WACA,MAAM;WACN,iBAAiB;;UAGX;;WAEN;;;;;;;;wBC9BK,8BACd,OAAO,uBAAuB,mBAC9B,UAAS,gCACR;;;;;;;;wBC5BmB,qBACpB,gBAAgB,sBAAsB,uBACrC,QAAQ;UAYM;;WAEN;;WAEA;;;;;;WAMA;;;;;;;;wBASW,yBACpB,gBACA,OAAM,4BACL,QAAQ;;;;;wBAwCW,6BACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;;wBAiBW,sBAAsB,eAAe;;;;;;;wBC/F3C,4BAA4B,GAAG;wBA8E/B,4BAA4B,GAAG;wBAsL/B,+BACd,QAAQ,qBACR;;;;;;;;;;;;;KC3QU;;UAQK;WACN,SAAS;WACT,SAAS;;;;;;wBA4DE,wBACpB,yBACA,KAAI,yBACH;;;UC/Cc;;WAEN;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;wBAwBK,0BACd,KAAK,sBACL,OAAM,2BACL;;;UCwsBc;;;;;;WAMN;;;;;;;;;;;;;;;;;;;wBA0EW,yBACpB,gBACA,OAAM,uBACL,QAAQ;;wBAoFK,2BACd,gBACA,OAAM,uBACL;;;;;;wBASmB,0BAA0B,iBAAiB;;;;qBCn8BpD;;qBAIA;UAEI;;WAEN,OAAO;;WAEP,QAAQ;;;;;WAKR,SAAS;;UAGH;WACN,WAAW;WACX,iBAAiB,SAAS;;;;;WAK1B,WAAW;;WAEX,SAAS,SAAS;;;;;WAKlB;;wBAuBK,mBAAmB,OAAO,sBAAsB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/supervisor-run/analyze.ts","../../src/supervisor-run/claude-code-reader.ts","../../src/supervisor-run/integrity-types.ts","../../src/supervisor-run/integrity.ts","../../src/supervisor-run/patch-stats.ts","../../src/supervisor-run/reader.ts","../../src/supervisor-run/render.ts","../../src/supervisor-run/report-command.ts","../../src/supervisor-run/source-facts.ts","../../src/supervisor-run/rollout-nodes.ts","../../src/supervisor-run/rollup.ts","../../src/supervisor-run/runtime-reader.ts","../../src/supervisor-run/terminal-record.ts"],"mappings":";;;;;;;wBAmDgB,4BACd,KAAK,sBACL,qBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UCoBc;;WAEN;;;;;WAKA;WACA;WACA;WACA;WACA;WACA;WACA;;;;qBCrFE;KAED;KAEA;KAKA;UAqCK;WACN;WACA;;UAGM;WACN,MAAM;WACN;WACA,UAAU;WACV;WACA;WACA;WACA,mBAAmB;WACnB;WACA,WAAW,SAAS;;UAGd;WACN,eAAe;WACf;WACA;WACA,MAAM;WACN,iBAAiB;;UAGX;;WAEN;;;;;;;;wBC9BK,8BACd,OAAO,uBAAuB,mBAC9B,UAAS,gCACR;;;;wBC5Ca,WAAW,eAAe;;;;;;;;wBCgBpB,qBACpB,gBAAgB,sBAAsB,uBACrC,QAAQ;UAYM;;WAEN;;WAEA;;;;;;WAMA;;;;;;;;wBAeW,sBAAsB,eAAe;;;;;;;wBCtC3C,4BAA4B,GAAG;wBA8E/B,4BAA4B,GAAG;wBAsL/B,+BACd,QAAQ,qBACR;;;;;;;;;;;;;KC1QU;;UAQK;WACN,SAAS;WACT,SAAS;;;;UCIV;EACR;EACA;EACA;EACA;;EAEA;;;;;;EAMA;;UAGQ;WACC,YAAY,kBAAkB;EACvC,QAAQ;;;;;;EAMR;EACA;;;;;;EAMA;;UA6Ge;;EAEf;EACA;EACA;EACA;;EAEA,MAAM;;EAEN;;EAEA;EACA;;EAEA;EACA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,OAAO;;EAEP;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA,eAAe;EACf,uBAAuB;;UAGR;;EAEf;EACA;;UAGe;;EAEf;;EAEA;EACA;;;;;;UAOe;WACN,2BAA2B;WAC3B;WACA,iBAAiB;WACjB,iBAAiB;WACjB,uBAAuB;WACvB,uBAAuB;WACvB;;;;;;;IAOP;IACA;IACA;IACA;;IAEA;;IAEA;;IAEA;IACA;;IAEA;;IAEA;IACA;;IAEA;;WAEO,YAAY,oBAAoB;;WAEhC,wBAAwB;;WAExB;;;;;;;;;WASA;;WAEA;;;;;;WAMA,0BAA0B,SAAS;;;;;;;WAOnC;;WAEA,gBAAgB;;WAEhB,OAAO;WACP;WACA;;;;;;WAMA;WACA;;;;;;;;;;;;;;;;;;KAmDC;wBAiFI,oBAAoB,KAAK,uBAAuB;;;UCva/C;;WAEN;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;wBAwBK,0BACd,KAAK,sBACL,OAAM,2BACL;;;;;;;;wBCnFa,qBAAqB,kBAAkB,wBAAwB;;;UCwrB9D;;;;;;WAMN;;;;;;;;;;;;;;;;;;;wBA0EW,yBACpB,gBACA,OAAM,uBACL,QAAQ;;;;;;wBA0FW,0BAA0B,iBAAiB;;;;qBC11BpD;;qBAIA;UAEI;;WAEN,OAAO;;WAEP,QAAQ;;;;;WAKR,SAAS;;UAGH;WACN,WAAW;WACX,iBAAiB,SAAS;;;;;WAK1B,WAAW;;WAEX,SAAS,SAAS;;;;;WAKlB;;wBAmBK,mBAAmB,OAAO,sBAAsB"}