@tangle-network/agent-eval 0.178.0 → 0.180.0

package/dist/terminal-record-Ce9_UjRz.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"terminal-record-Ce9_UjRz.js","names":["unhandled"],"sources":["../src/supervisor-run/source-facts.ts","../src/supervisor-run/types.ts","../src/supervisor-run/terminal-record.ts"],"sourcesContent":["import type { SupervisorRunNodeRole, SupervisorRunSources } from './types'\n\n// ---------------------------------------------------------------------------\n// Journal shapes — structurally parsed. The journal is the contract, not the type.\n// ---------------------------------------------------------------------------\n\ninterface JournalEvent {\n  kind?: unknown\n  id?: unknown\n  parent?: unknown\n  label?: unknown\n  role?: unknown\n  profileDigest?: unknown\n  runtime?: unknown\n  status?: unknown\n  verdict?: unknown\n  reason?: unknown\n  infra?: unknown\n  seq?: unknown\n  at?: unknown\n  spend?: unknown\n  spent?: unknown\n}\n\ninterface Tokens {\n  input: number\n  output: number\n  cacheRead: number\n  cacheWrite: number\n  /** False when the event carried no cache counters at all — not \"zero cached\". */\n  hasCache: boolean\n  /**\n   * False only when the record carried `cacheBreakdownKnown: false` — Runtime's mark for a\n   * provider that reported a total without splitting cache reads from cache writes. The\n   * counters that ARE present are then a partial split, never a measured \"zero cached\".\n   */\n  breakdownKnown: boolean\n}\n\nexport interface SpendLike {\n  tokens: Tokens\n  /**\n   * False only when the record carried `tokensKnown: false` — Runtime's mark for work that\n   * HAPPENED with an unreported token count. `tokens` then holds the known subtotal (often\n   * zero), never the measured total. An absent flag means the record is complete.\n   */\n  tokensKnown: boolean\n  usd: number\n  /**\n   * False only when the record carried `usdKnown: false` — work that HAPPENED at a price the\n   * provider never reported. `usd` then holds a catalog estimate or zero, never a measured\n   * price. An absent flag means the record is complete.\n   */\n  usdKnown: boolean\n}\n\nexport function asRecord(v: unknown): Record<string, unknown> {\n  return typeof v === 'object' && v !== null ? (v as Record<string, unknown>) : {}\n}\n\nfunction num(v: unknown): number {\n  return typeof v === 'number' && Number.isFinite(v) ? v : 0\n}\n\nfunction readSpend(v: unknown): SpendLike {\n  const rec = asRecord(v)\n  const tok = asRecord(rec.tokens)\n  const cacheRead = tok.cacheRead ?? tok.cache_read\n  const cacheWrite = tok.cacheWrite ?? tok.cache_write\n  return {\n    tokens: {\n      input: num(tok.input),\n      output: num(tok.output),\n      cacheRead: num(cacheRead),\n      cacheWrite: num(cacheWrite),\n      hasCache: cacheRead !== undefined || cacheWrite !== undefined,\n      breakdownKnown: tok.cacheBreakdownKnown !== false,\n    },\n    tokensKnown: rec.tokensKnown !== false,\n    usd: num(rec.usd),\n    usdKnown: rec.usdKnown !== false,\n  }\n}\n\nexport function parseJsonl(text: string | null): Record<string, unknown>[] {\n  return parseJsonlWithDiagnostics(text).rows\n}\n\ninterface ParsedJsonl {\n  readonly rows: Record<string, unknown>[]\n  readonly invalidRows: number\n}\n\nfunction parseJsonlWithDiagnostics(text: string | null): ParsedJsonl {\n  if (text === null) return { rows: [], invalidRows: 0 }\n  const out: Record<string, unknown>[] = []\n  let invalidRows = 0\n  for (const line of text.split('\\n')) {\n    const trimmed = line.trim()\n    if (!trimmed) continue\n    try {\n      const parsed: unknown = JSON.parse(trimmed)\n      if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {\n        out.push(parsed as Record<string, unknown>)\n      } else {\n        invalidRows += 1\n      }\n    } catch {\n      invalidRows += 1\n    }\n  }\n  return { rows: out, invalidRows }\n}\n\nexport function parseJson(text: string | null): Record<string, unknown> | null {\n  if (text === null) return null\n  try {\n    const parsed: unknown = JSON.parse(text)\n    return typeof parsed === 'object' && parsed !== null\n      ? (parsed as Record<string, unknown>)\n      : null\n  } catch {\n    return null\n  }\n}\n\nfunction ms(at: unknown): number | null {\n  if (typeof at !== 'string') return null\n  const t = Date.parse(at)\n  return Number.isFinite(t) ? t : null\n}\n\n// ---------------------------------------------------------------------------\n// The supervision tree, as parsed from the journal event stream.\n// ---------------------------------------------------------------------------\n\nexport interface SpawnRow {\n  /** Zero-based row among parsed journal objects. */\n  sourceRow: number\n  id: string\n  parent: string | null\n  label: string\n  /** Null when the source did not explicitly record a role. */\n  role: SupervisorRunNodeRole | null\n  /** Exact canonical AgentProfile digest, when the source recorded one. */\n  profileDigest: string | null\n  /** Exact execution runtime tag, when the source recorded one. */\n  runtime: string | null\n  at: number | null\n  /** False when identity, parentage, label, or role was malformed. */\n  valid: boolean\n  invalidFields: readonly string[]\n}\n\nexport interface CloseRow {\n  id: string\n  kind: 'settled' | 'cancelled'\n  status: string | null\n  /** String verdict from legacy journals, or valid/invalid for a structured verdict. */\n  verdict: string | null\n  /** Structured verdict validity, when recorded. */\n  valid: boolean | null\n  /** Structured verdict score, preserved without boolean coercion. */\n  score: number | null\n  /** The verdict exactly as the journal carried it. */\n  rawVerdict: unknown | null\n  /** Terminal failure detail exactly as recorded. */\n  reason: string | null\n  /** Whether Runtime classified the failure as infrastructure-caused. */\n  infra: boolean | null\n  at: number | null\n  spend: SpendLike\n  /** False when the close event carried no spend object — not \"spent nothing\". */\n  hasSpend: boolean\n}\n\nexport interface WorkerLogFacts {\n  /** Position in `SupervisorRunSources.workers`, retained for exact evidence paths. */\n  sourceIndex: number\n  workerId: string | null\n  label: string\n  /** `false` means the artifact was missing; a captured empty artifact is `true`. */\n  inboxCaptured: boolean\n  eventsCaptured: boolean\n  inboxInvalidRows: number\n  eventsInvalidRows: number\n  started: number | null\n  /** True once a `finished` event was seen — independent of whether its `at` parsed. */\n  finished: boolean\n  finishedAt: number | null\n  passed: boolean | null\n  /** Numeric score exactly as the finished event recorded it. */\n  score: number | null\n  /** `patchBytes` as reported by the finished event (not the patch file's size). */\n  finishedPatchBytes: number | null\n  evidenceBytes: number\n  /** Unique queued request ids, or null when exact accounting is unavailable. */\n  steersQueued: number | null\n  /** Unique matched request ids acknowledged as delivered, or null when unavailable. */\n  steersDelivered: number | null\n  steersQueuedUnavailable: string | null\n  steersDeliveredUnavailable: string | null\n  questions: number\n  steerRequests: SteerRequestFact[]\n  steerAcknowledgements: SteerAcknowledgementFact[]\n}\n\nexport interface SteerRequestFact {\n  /** Durable inbox request id; null when the row did not retain one. */\n  requestId: string | null\n  row: number\n}\n\nexport interface SteerAcknowledgementFact {\n  /** Worker event request id; null when the event cannot be correlated. */\n  requestId: string | null\n  /** `null` means the acknowledgement omitted delivery status. */\n  delivered: boolean | null\n  row: number\n}\n\n/**\n * The tree + timeline the report is computed from, exposed because the rollout-row\n * minter needs exactly the same parse (one parser, two consumers).\n */\nexport interface SupervisorTreeFacts {\n  readonly rootId: string | null\n  readonly spawns: readonly SpawnRow[]\n  readonly closes: readonly CloseRow[]\n  readonly workerSpawns: readonly SpawnRow[]\n  readonly workerCloses: readonly CloseRow[]\n  readonly brain: {\n    /**\n     * Summed over the root's metered rows that reported a token count. A row Runtime marked\n     * `tokensKnown: false` is EXCLUDED and counted in `tokensUnknownCount` instead, because\n     * its `tokens` field holds a known subtotal — folding it in would price unreported work\n     * at zero tokens.\n     */\n    tokensIn: number\n    tokensOut: number\n    cacheRead: number\n    cacheWrite: number\n    /** False when no metered event carried cache counters — not \"nothing cached\". */\n    hasCache: boolean\n    /** False when any folded metered row declared `cacheBreakdownKnown: false`. */\n    cacheBreakdownKnown: boolean\n    /** Root metered rows that reported a token count, and rows that did not. */\n    tokensKnownCount: number\n    tokensUnknownCount: number\n    /** Summed over the root's metered rows that reported a price, on the same rule. */\n    usd: number\n    /** Root metered rows that reported a price, and rows Runtime marked `usdKnown: false`. */\n    usdKnownCount: number\n    usdUnknownCount: number\n    /** Root-attributed metered events only — every row this object folded or counted. */\n    meteredCount: number\n  }\n  readonly workerLogs: ReadonlyMap<string, WorkerLogFacts>\n  /** Every worker source row, including duplicate identities that a map cannot retain. */\n  readonly workerLogRows: readonly WorkerLogFacts[]\n  /** Every non-empty journal line, whatever shape it turned out to have. */\n  readonly journalRows: number\n  /**\n   * Journal lines this parser could not interpret at all: invalid JSON, non-objects, and\n   * JSON objects carrying no record shape it recognizes.\n   *\n   * This count is what separates \"the run was empty\" from \"the input was unreadable\".\n   * Zero spawns with zero invalid rows is a positive claim that nothing happened; it must\n   * only ever be made about bytes the parser actually understood.\n   */\n  readonly journalInvalidRows: number\n  /** The `journalInvalidRows` subset that was not valid JSON, or not a JSON object. */\n  readonly journalMalformedJsonRows: number\n  /**\n   * Records recognized but deliberately not folded into the tree, counted by kind — the\n   * runtime envelope's `begin` header and the `waiting` / `woken` wait-node events. Kept\n   * separate from `journalInvalidRows` because these rows were understood, not rejected.\n   */\n  readonly journalIgnoredRowsByKind: Readonly<Record<string, number>>\n  /**\n   * Every metered row read, root-attributed or not. `brain.meteredCount` covers only the\n   * root's own spend; a nested driver's metered rows are understood but reach this tree\n   * through that driver's settled close, so this total is what keeps row accounting exact:\n   * journalRows = spawns + closes + journalMeteredRows + ignored + journalInvalidRows.\n   */\n  readonly journalMeteredRows: number\n  /** Which dialect(s) the journal's rows were actually written in. */\n  readonly journalDialect: SupervisorJournalDialect\n  /** Parsed once with the journal and worker artifacts. */\n  readonly state: Record<string, unknown> | null\n  readonly startedAt: number | null\n  readonly completedAt: number | null\n  /**\n   * First and last stamped tree events (spawned / settled / cancelled /\n   * metered) in the journal — the bounds of observed activity. They derive a\n   * lower-bound wall for a store that writes no completion stamp.\n   */\n  readonly firstEventAt: number | null\n  readonly lastEventAt: number | null\n}\n\ninterface VerdictFacts {\n  label: string | null\n  valid: boolean | null\n  score: number | null\n  raw: unknown | null\n}\n\nfunction readVerdict(v: unknown): VerdictFacts {\n  if (typeof v === 'string') return { label: v, valid: null, score: null, raw: v }\n  if (typeof v !== 'object' || v === null) {\n    return { label: null, valid: null, score: null, raw: null }\n  }\n  const rec = v as Record<string, unknown>\n  const valid = typeof rec.valid === 'boolean' ? rec.valid : null\n  return {\n    label: valid === null ? null : valid ? 'valid' : 'invalid',\n    valid,\n    score: typeof rec.score === 'number' && Number.isFinite(rec.score) ? rec.score : null,\n    raw: v,\n  }\n}\n\nexport function workerSourceKey(\n  worker: NonNullable<SupervisorRunSources['workers']>[number],\n): string {\n  return worker.workerId ?? worker.label\n}\n\n// ---------------------------------------------------------------------------\n// Journal dialects — the two shapes a supervision journal is actually written in.\n// ---------------------------------------------------------------------------\n\n/**\n * How a journal's rows were shaped on disk.\n *\n * `flat` — one event object per line (`{kind:'spawned', id, ...}`). The loops\n * supervisor writes this, and `readClaudeCodeSupervisorRun` synthesizes it.\n *\n * `runtime-envelope` — the records `agent-runtime`'s `FileSpawnJournal` writes:\n * a `{kind:'begin', root, at}` header followed by `{kind:'event', root, event}`\n * envelopes (`agent-runtime/src/durable/spawn-journal.ts`, `appendRecord`). It is\n * the layout `createFileRunContext(dir)` produces at `<dir>/spawn-journal.jsonl`.\n * This dialect is READ, not tolerated: agent-runtime is the writer, so a reader\n * that could not interpret it was the defect, and `journalDialect` records which\n * shape the bytes actually had so an unexpected one is never invisible.\n *\n * `mixed` — rows of both shapes in one file. `none` — no interpretable row at all.\n */\nexport type SupervisorJournalDialect = 'none' | 'flat' | 'runtime-envelope' | 'mixed'\n\ntype JournalRowDialect = 'flat' | 'runtime-envelope'\n\n/** Event kinds this parser folds into the tree. */\nconst TREE_EVENT_KINDS = ['spawned', 'settled', 'cancelled', 'metered'] as const\ntype TreeEventKind = (typeof TREE_EVENT_KINDS)[number]\n\n/**\n * Event kinds `agent-runtime` journals that this parser recognizes but does not model as\n * tree nodes: `waiting` arms a wait node and `woken` settles it. They are counted by kind\n * rather than dropped, so \"understood, not modeled\" can never be mistaken for \"absent\".\n */\nconst UNMODELLED_EVENT_KINDS: readonly string[] = ['waiting', 'woken']\n\nfunction treeEventKind(value: unknown): TreeEventKind | null {\n  return (TREE_EVENT_KINDS as readonly unknown[]).includes(value) ? (value as TreeEventKind) : null\n}\n\ntype JournalRowReading =\n  | {\n      outcome: 'event'\n      dialect: JournalRowDialect\n      kind: TreeEventKind\n      event: JournalEvent\n    }\n  | { outcome: 'ignored'; dialect: JournalRowDialect; kind: string }\n  | { outcome: 'unreadable' }\n\n/**\n * Classify one parsed journal row. Every row lands in exactly one outcome — interpreted,\n * recognized-but-not-modeled, or unreadable — because a row that falls through silently is\n * how a run with events reads as a run with none.\n */\nfunction readJournalRow(row: Record<string, unknown>): JournalRowReading {\n  const kind = row.kind\n  if (typeof kind !== 'string') return { outcome: 'unreadable' }\n\n  // agent-runtime's FileSpawnJournal record header. It carries no event.\n  if (kind === 'begin' && typeof row.root === 'string') {\n    return { outcome: 'ignored', dialect: 'runtime-envelope', kind: 'begin' }\n  }\n  if (kind === 'event') {\n    const inner = row.event\n    if (typeof inner !== 'object' || inner === null || Array.isArray(inner)) {\n      return { outcome: 'unreadable' }\n    }\n    const innerKind = (inner as Record<string, unknown>).kind\n    if (typeof innerKind !== 'string') return { outcome: 'unreadable' }\n    const tree = treeEventKind(innerKind)\n    if (tree !== null) {\n      return {\n        outcome: 'event',\n        dialect: 'runtime-envelope',\n        kind: tree,\n        event: inner as JournalEvent,\n      }\n    }\n    // The envelope proves this IS a journaled event, so an unmodelled kind is recorded by\n    // name rather than called unreadable — the caller sees exactly what went uncounted.\n    return { outcome: 'ignored', dialect: 'runtime-envelope', kind: innerKind }\n  }\n\n  const tree = treeEventKind(kind)\n  if (tree !== null) {\n    return { outcome: 'event', dialect: 'flat', kind: tree, event: row as JournalEvent }\n  }\n  if (UNMODELLED_EVENT_KINDS.includes(kind)) {\n    return { outcome: 'ignored', dialect: 'flat', kind }\n  }\n  // A bare object with an unknown `kind` could be any record at all — unlike the envelope\n  // case there is no evidence it is a journal event, so it counts as unreadable (fail closed).\n  return { outcome: 'unreadable' }\n}\n\nfunction summarizeDialect(seen: ReadonlySet<JournalRowDialect>): SupervisorJournalDialect {\n  if (seen.size === 0) return 'none'\n  if (seen.size > 1) return 'mixed'\n  return seen.has('runtime-envelope') ? 'runtime-envelope' : 'flat'\n}\n\nexport function parseSupervisorTree(src: SupervisorRunSources): SupervisorTreeFacts {\n  const parsedJournal = parseJsonlWithDiagnostics(src.journal)\n  const events = parsedJournal.rows\n  const state = parseJson(src.state)\n\n  const spawns: SpawnRow[] = []\n  const closes: CloseRow[] = []\n  let brainIn = 0\n  let brainOut = 0\n  let brainCacheRead = 0\n  let brainCacheWrite = 0\n  let brainHasCache = false\n  let brainCacheBreakdownKnown = true\n  let brainTokensKnownCount = 0\n  let brainTokensUnknownCount = 0\n  let brainUsd = 0\n  let brainUsdKnownCount = 0\n  let brainUsdUnknownCount = 0\n  let meteredCount = 0\n  let rootId: string | null = null\n  let unreadableRows = 0\n  const ignoredByKind = new Map<string, number>()\n  const dialectsSeen = new Set<JournalRowDialect>()\n  const meteredRows: Array<{ id: string; spend: SpendLike; at: number | null }> = []\n  for (const [sourceRow, row] of events.entries()) {\n    const reading = readJournalRow(row)\n    if (reading.outcome === 'unreadable') {\n      unreadableRows += 1\n      continue\n    }\n    dialectsSeen.add(reading.dialect)\n    if (reading.outcome === 'ignored') {\n      ignoredByKind.set(reading.kind, (ignoredByKind.get(reading.kind) ?? 0) + 1)\n      continue\n    }\n    const { kind, event: ev } = reading\n    const id = typeof ev.id === 'string' ? ev.id : ''\n    if (kind === 'spawned') {\n      const parent = typeof ev.parent === 'string' && ev.parent.length > 0 ? ev.parent : null\n      const label = typeof ev.label === 'string' ? ev.label : ''\n      const invalidFields: string[] = []\n      if (id.length === 0) invalidFields.push('id')\n      const parentOmittedForFirstRoot = ev.parent === undefined && rootId === null\n      if (\n        ev.parent !== null &&\n        !parentOmittedForFirstRoot &&\n        !(typeof ev.parent === 'string' && ev.parent.length > 0)\n      ) {\n        invalidFields.push('parent')\n      }\n      if (label.length === 0) invalidFields.push('label')\n      if (ev.role !== undefined && ev.role !== 'supervisor' && ev.role !== 'worker') {\n        invalidFields.push('role')\n      }\n      if (\n        ev.profileDigest !== undefined &&\n        !(typeof ev.profileDigest === 'string' && ev.profileDigest.length > 0)\n      ) {\n        invalidFields.push('profileDigest')\n      }\n      if (ev.runtime !== undefined && !(typeof ev.runtime === 'string' && ev.runtime.length > 0)) {\n        invalidFields.push('runtime')\n      }\n      const role: SupervisorRunNodeRole | null =\n        ev.role === 'supervisor' || ev.role === 'worker' ? ev.role : null\n      const valid = invalidFields.length === 0\n      if (valid && parent === null && rootId === null) rootId = id\n      spawns.push({\n        sourceRow,\n        id,\n        parent,\n        label,\n        role,\n        profileDigest:\n          typeof ev.profileDigest === 'string' && ev.profileDigest.length > 0\n            ? ev.profileDigest\n            : null,\n        runtime: typeof ev.runtime === 'string' && ev.runtime.length > 0 ? ev.runtime : null,\n        at: ms(ev.at),\n        valid,\n        invalidFields,\n      })\n    } else if (kind === 'settled') {\n      const verdict = readVerdict(ev.verdict)\n      closes.push({\n        id,\n        kind: 'settled',\n        status: typeof ev.status === 'string' ? ev.status : null,\n        verdict: verdict.label,\n        valid: verdict.valid,\n        score: verdict.score,\n        rawVerdict: verdict.raw,\n        reason: typeof ev.reason === 'string' ? ev.reason : null,\n        infra: typeof ev.infra === 'boolean' ? ev.infra : null,\n        at: ms(ev.at),\n        spend: readSpend(ev.spent),\n        hasSpend: asRecord(ev.spent).tokens !== undefined,\n      })\n    } else if (kind === 'cancelled') {\n      closes.push({\n        id,\n        kind: 'cancelled',\n        status: 'cancelled',\n        verdict: typeof ev.reason === 'string' ? ev.reason : null,\n        valid: null,\n        score: null,\n        rawVerdict: typeof ev.reason === 'string' ? ev.reason : null,\n        reason: typeof ev.reason === 'string' ? ev.reason : null,\n        infra: null,\n        at: ms(ev.at),\n        spend: {\n          tokens: {\n            input: 0,\n            output: 0,\n            cacheRead: 0,\n            cacheWrite: 0,\n            hasCache: false,\n            breakdownKnown: true,\n          },\n          tokensKnown: true,\n          usd: 0,\n          usdKnown: true,\n        },\n        hasSpend: false,\n      })\n    } else if (kind === 'metered') {\n      // Deferred: rows are attributed after the loop, once the root is known, so a metered\n      // event that precedes the root spawn is never misattributed.\n      meteredRows.push({ id, spend: readSpend(ev.spend), at: ms(ev.at) })\n    } else {\n      // `TREE_EVENT_KINDS` and these branches are one contract: adding a kind to the set\n      // without a branch here would silently drop its rows, which is the defect this\n      // accounting exists to prevent. The compiler refuses the omission.\n      const unhandled: never = kind\n      throw new Error(`unhandled journal event kind ${JSON.stringify(unhandled)}`)\n    }\n  }\n\n  // Only root-attributed metered events are the supervisor brain's own spend. A nested\n  // driver meters under its own id; its spend reaches this tree through its settled close,\n  // so folding it into the brain here would count the same tokens twice.\n  for (const row of meteredRows) {\n    if (rootId === null || row.id !== rootId) continue\n    if (row.spend.tokensKnown) {\n      brainIn += row.spend.tokens.input\n      brainOut += row.spend.tokens.output\n      brainCacheRead += row.spend.tokens.cacheRead\n      brainCacheWrite += row.spend.tokens.cacheWrite\n      brainHasCache = brainHasCache || row.spend.tokens.hasCache\n      brainCacheBreakdownKnown = brainCacheBreakdownKnown && row.spend.tokens.breakdownKnown\n      brainTokensKnownCount += 1\n    } else {\n      brainTokensUnknownCount += 1\n    }\n    if (row.spend.usdKnown) {\n      brainUsd += row.spend.usd\n      brainUsdKnownCount += 1\n    } else {\n      brainUsdUnknownCount += 1\n    }\n    meteredCount += 1\n  }\n\n  const workerSpawns = spawns.filter((s) => s.valid && s.id !== rootId)\n  const workerIds = new Set(workerSpawns.map((s) => s.id))\n  const workerCloses = closes.filter((c) => workerIds.has(c.id))\n\n  const workerLogs = new Map<string, WorkerLogFacts>()\n  const workerLogRows: WorkerLogFacts[] = []\n  for (const [sourceIndex, w] of (src.workers ?? []).entries()) {\n    const facts: WorkerLogFacts = {\n      sourceIndex,\n      workerId: w.workerId ?? null,\n      label: w.label,\n      inboxCaptured: w.inbox !== null,\n      eventsCaptured: w.events !== null,\n      inboxInvalidRows: 0,\n      eventsInvalidRows: 0,\n      started: null,\n      finished: false,\n      finishedAt: null,\n      passed: null,\n      score: null,\n      finishedPatchBytes: null,\n      evidenceBytes: 0,\n      steersQueued: null,\n      steersDelivered: null,\n      steersQueuedUnavailable: null,\n      steersDeliveredUnavailable: null,\n      questions: 0,\n      steerRequests: [],\n      steerAcknowledgements: [],\n    }\n    const parsedInbox = parseJsonlWithDiagnostics(w.inbox)\n    const parsedEvents = parseJsonlWithDiagnostics(w.events)\n    facts.inboxInvalidRows = parsedInbox.invalidRows\n    facts.eventsInvalidRows = parsedEvents.invalidRows\n    for (const [row, req] of parsedInbox.rows.entries()) {\n      if (typeof req.message !== 'string' || req.message.trim().length === 0) continue\n      facts.steerRequests.push({\n        requestId: typeof req.id === 'string' && req.id.length > 0 ? req.id : null,\n        row,\n      })\n    }\n    for (const [row, ev] of parsedEvents.rows.entries()) {\n      const kind = ev.kind\n      if (kind === 'message') {\n        if (ev.direction === 'up') {\n          facts.questions += 1\n          continue\n        }\n        facts.steerAcknowledgements.push({\n          requestId:\n            typeof ev.requestId === 'string' && ev.requestId.length > 0 ? ev.requestId : null,\n          delivered: typeof ev.delivered === 'boolean' ? ev.delivered : null,\n          row,\n        })\n      } else if (kind === 'started') {\n        facts.started = ms(ev.at)\n      } else if (kind === 'finished') {\n        facts.finished = true\n        facts.finishedAt = ms(ev.at)\n        facts.passed = typeof ev.passed === 'boolean' ? ev.passed : null\n        facts.score = typeof ev.score === 'number' && Number.isFinite(ev.score) ? ev.score : null\n        facts.finishedPatchBytes = typeof ev.patchBytes === 'number' ? ev.patchBytes : null\n        facts.evidenceBytes = typeof ev.evidence === 'string' ? ev.evidence.length : 0\n      }\n    }\n    const requestsById = new Map<string, number>()\n    for (const request of facts.steerRequests) {\n      if (request.requestId === null) continue\n      requestsById.set(request.requestId, (requestsById.get(request.requestId) ?? 0) + 1)\n    }\n    const acknowledgementsById = new Map<string, SteerAcknowledgementFact[]>()\n    for (const acknowledgement of facts.steerAcknowledgements) {\n      if (acknowledgement.requestId === null) continue\n      const matches = acknowledgementsById.get(acknowledgement.requestId) ?? []\n      matches.push(acknowledgement)\n      acknowledgementsById.set(acknowledgement.requestId, matches)\n    }\n    const queueProblems: string[] = []\n    if (!facts.inboxCaptured) queueProblems.push('inbox absent')\n    if (!facts.eventsCaptured) queueProblems.push('events absent')\n    if (facts.inboxInvalidRows > 0) queueProblems.push('inbox contains malformed rows')\n    if (facts.eventsInvalidRows > 0) queueProblems.push('events contain malformed rows')\n    if (facts.steerRequests.some((request) => request.requestId === null)) {\n      queueProblems.push('queued request id missing')\n    }\n    if ([...requestsById.values()].some((count) => count > 1)) {\n      queueProblems.push('queued request id duplicated')\n    }\n    if (facts.steerAcknowledgements.some((acknowledgement) => acknowledgement.requestId === null)) {\n      queueProblems.push('acknowledgement request id missing')\n    }\n    if ([...acknowledgementsById.keys()].some((id) => !requestsById.has(id))) {\n      queueProblems.push('acknowledgement has no queued request')\n    }\n    if (queueProblems.length === 0) {\n      facts.steersQueued = requestsById.size\n    } else {\n      facts.steersQueuedUnavailable = [...new Set(queueProblems)].join('; ')\n    }\n\n    const deliveryProblems = [...queueProblems]\n    if ([...acknowledgementsById.values()].some((rows) => rows.length > 1)) {\n      deliveryProblems.push('acknowledgement request id duplicated')\n    }\n    if (facts.steerAcknowledgements.some((acknowledgement) => acknowledgement.delivered === null)) {\n      deliveryProblems.push('acknowledgement delivery status missing')\n    }\n    if (deliveryProblems.length === 0) {\n      facts.steersDelivered = [...requestsById.keys()].filter((id) => {\n        const acknowledgement = acknowledgementsById.get(id)\n        return acknowledgement?.length === 1 && acknowledgement[0]?.delivered === true\n      }).length\n    } else {\n      facts.steersDeliveredUnavailable = [...new Set(deliveryProblems)].join('; ')\n    }\n    workerLogRows.push(facts)\n    workerLogs.set(workerSourceKey(w), facts)\n  }\n\n  const startedAt = ms(state?.startedAt) ?? spawns[0]?.at ?? null\n  const rootClose = rootId === null ? null : closes.find((close) => close.id === rootId)\n  const completedAt = ms(state?.completedAt) ?? rootClose?.at ?? null\n\n  let firstEventAt: number | null = null\n  let lastEventAt: number | null = null\n  const widenEventSpan = (at: number | null): void => {\n    if (at === null) return\n    if (firstEventAt === null || at < firstEventAt) firstEventAt = at\n    if (lastEventAt === null || at > lastEventAt) lastEventAt = at\n  }\n  for (const spawn of spawns) widenEventSpan(spawn.at)\n  for (const close of closes) widenEventSpan(close.at)\n  for (const metered of meteredRows) widenEventSpan(metered.at)\n\n  return {\n    rootId,\n    spawns,\n    closes,\n    workerSpawns,\n    workerCloses,\n    brain: {\n      tokensIn: brainIn,\n      tokensOut: brainOut,\n      cacheRead: brainCacheRead,\n      cacheWrite: brainCacheWrite,\n      hasCache: brainHasCache,\n      cacheBreakdownKnown: brainCacheBreakdownKnown,\n      tokensKnownCount: brainTokensKnownCount,\n      tokensUnknownCount: brainTokensUnknownCount,\n      usd: brainUsd,\n      usdKnownCount: brainUsdKnownCount,\n      usdUnknownCount: brainUsdUnknownCount,\n      meteredCount,\n    },\n    workerLogs,\n    workerLogRows,\n    journalRows: events.length + parsedJournal.invalidRows,\n    journalInvalidRows: parsedJournal.invalidRows + unreadableRows,\n    journalMalformedJsonRows: parsedJournal.invalidRows,\n    journalIgnoredRowsByKind: Object.fromEntries(ignoredByKind),\n    journalMeteredRows: meteredRows.length,\n    journalDialect: summarizeDialect(dialectsSeen),\n    state,\n    startedAt,\n    completedAt,\n    firstEventAt,\n    lastEventAt,\n  }\n}\n","/**\n * Supervisor-run analysis — the multi-agent analogue of single-rollout trace\n * analysis. A solo rollout is one invocation with a transcript; a supervisor\n * run is a TREE of invocations (a brain that spawns, steers, and settles\n * workers) plus the event timeline that connects them. `src/trace-analyst`\n * answers \"what happened inside one session\"; this module answers \"what did\n * the tree do\" — did the brain steer anyone mid-task, how many spawn waves,\n * how concurrent, how idle, what did each role cost, what came back.\n *\n * The nodes of that tree are NOT a new shape: they are `tangle.rollout.v1`\n * rows (`src/rollout`), keyed by `parent_rollout_id`, with `role` already\n * spanning `supervisor` / `worker`. `supervisorRunRolloutLines` mints them.\n * What rollout rows deliberately do NOT carry is the inter-invocation event\n * timeline (spawn/settle/steer instants), which is what every structural\n * metric here is computed from — so the reader consumes the journal event\n * stream and emits rollout rows, rather than maintaining a parallel node type.\n *\n * ## UNAVAILABLE ≠ ZERO\n *\n * Every metric whose backing artifact can be missing is typed\n * `Measured<T> = T | { unavailable: reason }`. A supervisor that steered\n * nobody reports `steers: 0`; a supervisor whose worker logs were never\n * written reports `steers: unavailable — <reason>`. The two have driven\n * opposite conclusions about the same architecture, so they never collapse.\n */\n\nimport type { RolloutLine } from '../rollout/schema'\nimport type { SeriesDistribution } from '../statistics'\n\n// ---------------------------------------------------------------------------\n// Unavailable-aware metric type.\n// ---------------------------------------------------------------------------\n\n/** A metric that could not be computed, with the reason its artifact was missing. */\nexport interface Unavailable {\n  readonly unavailable: string\n}\n\n/** A metric value, or the reason it is unknown. NEVER collapse `unavailable` to 0. */\nexport type Measured<T> = T | Unavailable\n\nexport function unavailable(reason: string): Unavailable {\n  return { unavailable: reason }\n}\n\nexport function isUnavailable(v: unknown): v is Unavailable {\n  return typeof v === 'object' && v !== null && typeof (v as Unavailable).unavailable === 'string'\n}\n\n/** Render a measured scalar for the markdown/headline: `0` and `unavailable` stay distinct. */\nexport function showMeasured(v: Measured<number | string | boolean | null>): string {\n  if (isUnavailable(v)) return `unavailable — ${v.unavailable}`\n  if (v === null) return 'null'\n  return String(v)\n}\n\n// ---------------------------------------------------------------------------\n// Source contract — deliberately source-agnostic.\n// ---------------------------------------------------------------------------\n\n/** The two invocation roles a recursive supervision tree can contain. */\nexport type SupervisorRunNodeRole = 'supervisor' | 'worker'\n\n/**\n * One worker's logs, as read. `null` means the artifact did not exist; `''`\n * means the artifact was captured and contained no rows.\n */\nexport interface WorkerLogSource {\n  /**\n   * Stable journal node id. Readers should set this whenever their source has\n   * one; `label` remains the compatibility join for older stores.\n   */\n  readonly workerId?: string\n  /** Human-readable task label. It is not required to be unique. */\n  readonly label: string\n  /** Worker event stream — started / progress / finished / message events (JSONL). */\n  readonly events: string | null\n  /** The durable steer queue — one line per steer request (JSONL). */\n  readonly inbox: string | null\n  /** Worker patch byte length, or null when absent. */\n  readonly patchBytes: number | null\n  /** Where this worker's transcript lives, for the rollout row. Null = no such artifact. */\n  readonly transcriptRef?: string | null\n  /** Where this worker's delivered patch lives. Null = the store keeps no patch per worker. */\n  readonly patchPath?: string | null\n  /** This worker's own inference tokens, when the store records them per worker. */\n  readonly tokensIn?: number | null\n  readonly tokensOut?: number | null\n  readonly cacheRead?: number | null\n  readonly cacheWrite?: number | null\n}\n\n/**\n * Facts a SOURCE structurally cannot express, each with the reason.\n *\n * The difference between \"the artifact is missing\" and \"this store never\n * records that fact\" is the difference between a run that spent $0 and a\n * harness that does not price inference — and the second harness is where a\n * loops-shaped assumption becomes a fabricated zero. A reader declares its\n * limits once; the analyzer reports `unavailable` for everything downstream.\n *\n * `null` on a field means the source DOES carry that fact.\n */\nexport interface SourceLimits {\n  /** Reason manager input/output token totals are unavailable (null = recorded). */\n  readonly managerTokens: string | null\n  /** Reason worker input/output token totals are unavailable (null = recorded). */\n  readonly workerTokens: string | null\n  /** Reason inference spend has no price in this store (null = the store prices it). */\n  readonly spendUsd: string | null\n  /** Reason workers carry no pass/fail verdict (null = verdicts are recorded). */\n  readonly workerVerdicts: string | null\n  /** Reason no delivered artifact (patch/diff) is retained per worker (null = retained). */\n  readonly deliverables: string | null\n}\n\n/** A source that carries every fact the analyzer can use. */\nexport const NO_SOURCE_LIMITS: SourceLimits = {\n  managerTokens: null,\n  workerTokens: null,\n  spendUsd: null,\n  workerVerdicts: null,\n  deliverables: null,\n}\n\n/**\n * Everything the pure analyzer reads — already-read bytes, never paths. Each\n * field is `null` when its artifact was absent, which is what turns the\n * dependent metrics into `unavailable` rather than 0.\n *\n * This is the whole input contract. Any store that can produce these strings\n * (an on-disk loops run, an object-store archive, a database, a test fixture)\n * is a valid source; `loopsSupervisorRunReader` is ONE implementation.\n */\nexport interface SupervisorRunSources {\n  /** Stable identity of the run being analyzed (a directory, a run id, a URL). */\n  readonly runRef: string\n  readonly instanceId: string | null\n  /** Which arm/variant of a comparison this run is, when the run belongs to one. */\n  readonly arm: string | null\n  /** Identity of the supervision-tree store this was read from; null = none found. */\n  readonly supRunDir: string | null\n  /**\n   * Supervision journal — spawned / settled / cancelled / metered events (JSONL).\n   * Recursive readers put `role: 'supervisor' | 'worker'` on spawned rows;\n   * settled `verdict` may be a legacy string or `{ valid, score, ... }`.\n   */\n  readonly journal: string | null\n  /**\n   * Source-specific reason `journal` is null. The analyzer uses it verbatim as\n   * the `unavailable` reason on every journal-dependent metric, so a non-loops\n   * layout names its own journal file instead of inheriting the loops paths.\n   */\n  readonly journalMissingReason?: string\n  /** Per-brain-call tap (JSONL): finish_reason, completion tokens, requested max tokens. */\n  readonly brainLog: string | null\n  /** Source-specific reason `brainLog` is absent. */\n  readonly brainLogMissingReason?: string\n  /** Supervisor state document (JSON). */\n  readonly state: string | null\n  /** Supervisor progress stream (JSONL). */\n  readonly progress: string | null\n  /** Per-worker logs; `null` = the worker log store itself was missing. */\n  readonly workers: readonly WorkerLogSource[] | null\n  /** Why `workers` is null (only set when it is). */\n  readonly workersMissingReason: string | null\n  /**\n   * Run result document (JSON). For a Runtime run dir this is `result.json`,\n   * the `SupervisedResult` that `supervise()` returned, verbatim; its `kind`\n   * is the run's status. For a loops run dir it is the legacy result document.\n   */\n  readonly result: string | null\n  /**\n   * Runtime's terminal failure record (`failure.json`), written when\n   * `supervise()` threw before a result landed. `null` = the store was read and\n   * holds no such record; `undefined` = the store has no failure document at\n   * all (the loops layout), which the analyzer reports as its own absence.\n   */\n  readonly failure?: string | null\n  /**\n   * Judge verdict document (JSON), or the matching ledger row re-encoded as\n   * one. Runners that write the verdict straight to a ledger leave no judge\n   * document, so the ledger row is the same fact from the same run — not a\n   * substitute measurement.\n   */\n  readonly judge: string | null\n  /** Where `judge` came from, for the report's provenance line. */\n  readonly judgeSource: string | null\n  /** Delivered unified-diff patch text. */\n  readonly patch: string | null\n  /** Outer-driver log (used for the driver's steer verbs + deadline evidence). */\n  readonly driverLog: string | null\n  /**\n   * Worker tokens recovered from a harness session store; null = store unavailable.\n   * `store` names the store in the report's provenance line (e.g. `opencode`).\n   */\n  readonly harnessWorkerTokens: {\n    store: string\n    sessions: number\n    input: number\n    output: number\n    /** Cached prompt tokens, when the store counts them separately. */\n    cacheRead?: number\n    cacheWrite?: number\n  } | null\n  readonly harnessMissingReason: string | null\n  /** What this store structurally cannot record. See `SourceLimits`. */\n  readonly limits: SourceLimits\n  /**\n   * Where the ROOT invocation's transcript lives. Undefined lets the rollout\n   * minter fall back to the loops layout (`<supRunDir>/journal.jsonl`); any\n   * other store must say, or the row points at a path that never existed.\n   */\n  readonly rootTranscriptRef?: string | null\n  /**\n   * The `traces` CLI command that covers this run's harness-session layer.\n   * Null falls back to the analyzer's default (an opencode worker fleet).\n   */\n  readonly traceCommand: string | null\n}\n\n/**\n * A source of supervisor-run bytes. Implementations own their storage layout;\n * the analyzer only ever sees `SupervisorRunSources`.\n */\nexport interface SupervisorRunReader {\n  /** Stable identity of what this reader points at (for logs and report labels). */\n  readonly runRef: string\n  read(): Promise<SupervisorRunSources>\n}\n\n// ---------------------------------------------------------------------------\n// Report shape.\n// ---------------------------------------------------------------------------\n\nexport const SUPERVISOR_RUN_SCHEMA = 'tangle.supervisor-run@1'\nexport const SUPERVISOR_RUN_ROLLUP_SCHEMA = 'tangle.supervisor-run-rollup@1'\n\nexport interface SteerBreakdown {\n  /** Stable journal node id when the reader retained one. */\n  readonly workerId: string | null\n  readonly worker: string\n  /** Steer requests durably queued to this worker's inbox. */\n  readonly queued: number\n  /** Steers the worker's executor actually accepted (control event `delivered:true`). */\n  readonly delivered: number\n}\n\nexport interface OrchestrationMetrics {\n  readonly workersSpawned: Measured<number>\n  readonly workersSettled: Measured<number>\n  readonly workersCancelled: Measured<number>\n  /** THE HEADLINE: mid-task steers the brain sent to live workers. 0 ≠ unavailable. */\n  readonly steers: Measured<number>\n  readonly steersDelivered: Measured<number>\n  readonly steersByWorker: Measured<readonly SteerBreakdown[]>\n  /** Outer-driver `supervisor_steer` tool calls seen in the driver log (a second steer path). */\n  readonly driverSteerCalls: Measured<number>\n  /**\n   * Spawn waves. A wave is a maximal run of worker spawns with no settle/cancel between\n   * them: wave N+1 begins at the first spawn issued after at least one worker from an\n   * earlier wave has settled. Structural, not a time threshold — no tunable constant.\n   */\n  readonly waves: Measured<number>\n  readonly waveSizes: Measured<readonly number[]>\n  readonly maxConcurrency: Measured<number>\n  /** Direct-child spawns issued after that parent's first direct-child settlement. */\n  readonly respawns: Measured<number>\n  /** Labels spawned more than once by the same parent. */\n  readonly repeatedLabels: Measured<readonly string[]>\n  /** Longest parent chain below the root, in worker hops. */\n  readonly delegationDepth: Measured<number>\n  readonly timeToFirstSpawnMs: Measured<number>\n  readonly supervisorWallMs: Measured<number>\n  /**\n   * Which measurement `supervisorWallMs` holds — never a silent substitution.\n   * `stamps`: explicit start and completion stamps. `journal-span`: the start\n   * stamp (or first stamped event) to the last stamped journal event — a\n   * lower bound, derived when the store wrote no completion stamp. `idleMs`,\n   * `idlePct`, and `workerUtilization` cover the same span. Unavailable\n   * exactly when `supervisorWallMs` is, with the same reason.\n   */\n  readonly supervisorWallSource: Measured<'stamps' | 'journal-span'>\n  /** Wall time inside the supervisor run with ZERO live workers. */\n  readonly idleMs: Measured<number>\n  readonly idlePct: Measured<number>\n  /** sum(worker wall) / supervisor wall. >1 means real parallelism. */\n  readonly workerUtilization: Measured<number>\n}\n\nexport interface DecisionMetrics {\n  readonly settledByStatus: Measured<Record<string, number>>\n  readonly settledVerdicts: Measured<Record<string, number>>\n  /**\n   * Workers whose recorded verdict was green. A store that retains a delivered patch also\n   * requires patch bytes; a store that retains none accepts the verdict alone, because the\n   * verdict IS the acceptance decision that store recorded. `emptyPass` — the split that\n   * needs patch bytes — is what reads unavailable there.\n   */\n  readonly accepted: Measured<number>\n  /** Worker settled with a failing verify. */\n  readonly rejected: Measured<number>\n  /** Worker verified green but delivered no patch bytes — output with nothing to accept. */\n  readonly emptyPass: Measured<number>\n  /** Direct-child settlements a parent observed before issuing its next direct-child spawn. */\n  readonly observeThenRespawn: Measured<number>\n  /** Parent-local respawns with no direct-child settlement in front of them. */\n  readonly respawnWithoutEvidence: Measured<number>\n  /** Steer + question traffic on the live down/up legs — the only \"review while running\" signal. */\n  readonly reviewActions: Measured<number>\n  readonly workerEvidenceBytes: Measured<number>\n}\n\nexport interface RoleSpend {\n  readonly tokensIn: Measured<number>\n  readonly tokensOut: Measured<number>\n  /**\n   * Cached prompt tokens read/written. On a harness that caches aggressively\n   * these dwarf `tokensIn`, so a report that omits them understates the context\n   * each invocation actually consumed. `unavailable` = the store has no such counter.\n   */\n  readonly cacheRead: Measured<number>\n  readonly cacheWrite: Measured<number>\n  readonly usd: Measured<number>\n  readonly source: string\n}\n\nexport interface PerWorkerRow {\n  /** Stable journal node id when the reader retained one. */\n  readonly workerId: string | null\n  readonly worker: string\n  /** Explicit journal role after the worker source was joined to its spawn. */\n  readonly role: SupervisorRunNodeRole | null\n  /** Exact execution runtime tag from the spawn event. */\n  readonly runtime: string | null\n  /** Exact canonical AgentProfile digest from the spawn event. */\n  readonly profileDigest: string | null\n  /** Terminal lifecycle status exactly as recorded. */\n  readonly status: string | null\n  /** Terminal failure detail exactly as recorded. */\n  readonly failure: string | null\n  /** Runtime infrastructure classification, when recorded. */\n  readonly infra: boolean | null\n  readonly wallMs: number | null\n  /** `null` = this store does not attribute tokens per worker (NOT \"zero tokens\"). */\n  readonly tokensIn: number | null\n  readonly tokensOut: number | null\n  readonly usd: number | null\n  readonly patchBytes: number | null\n  readonly passed: boolean | null\n  /** Numeric verdict score exactly as recorded; null means no score was recorded. */\n  readonly score: number | null\n}\n\n/**\n * `SeriesDistribution` (from `../statistics`) over per-worker wall\n * milliseconds. The fold itself is `summarizeNumberSeries`, exported for any\n * series — fleet wall medians, tokens-per-claim spreads — not only wall.\n */\nexport type WallDistribution = SeriesDistribution\n\n/** One spend measurement and the number of source records behind it. */\nexport interface SpendMeasurement {\n  readonly usd: Measured<number>\n  /** Source records folded into `usd`; 0 when the measurement is unavailable. */\n  readonly records: number\n  /**\n   * Records the store wrote with `usdKnown: false` — work that HAPPENED at a price the\n   * provider never reported. Those records are NOT folded into `usd`, so a run with any\n   * of them has a `usd` that is a floor on real spend, never the measured total. Dropping\n   * the whole channel instead would discard the records that DID carry a price.\n   */\n  readonly unknownRecords: number\n  /** True exactly when `unknownRecords > 0`: `usd` covers some of the run, not all of it. */\n  readonly partial: boolean\n  /** Node ids behind `unknownRecords`, in journal order. Empty when none. */\n  readonly unknownNodes: readonly string[]\n}\n\n/**\n * The run's total inference spend, measured two ways.\n *\n * `closeRecord` is the spend the store recorded as settled when the run\n * closed (loops `state.json` `result.spentUsd`; Runtime `result.json`\n * `spentTotal.usd`) — the billing-shaped answer. `journalDerived` is the\n * spend execution observably consumed (journal `metered` + `settled` rows) —\n * the execution-accounting answer. Neither is canonical for the other's\n * question. The two cover different records at different moments, so\n * divergence between them is itself a signal (a dropped settlement, a\n * double meter, spend after the close) — read it, never average it away.\n */\nexport interface SpendMeasurements {\n  readonly journalDerived: SpendMeasurement\n  readonly closeRecord: SpendMeasurement\n}\n\nexport interface EconomicsMetrics {\n  /** Driver/brain inference — journal `metered` events. */\n  readonly brain: RoleSpend\n  /**\n   * Brain completions that came back `finish_reason: \"length\"` — output TRUNCATED. Any value\n   * above 0 means the supervisor planned into a wall and then acted on the half-written plan,\n   * which is a defect and not a cost figure. The journal's `metered` rows carry token counts\n   * but no finish reason, so this reads the per-call brain tap; a run whose supervisor\n   * predates that tap reports `unavailable`, never 0.\n   */\n  readonly brainTruncations: Measured<number>\n  /** Worker inference — journal `settled` spend plus the harness session join. */\n  readonly workers: RoleSpend\n  /** Both total-spend measurements, each with its own record count. */\n  readonly spend: SpendMeasurements\n  /**\n   * One collapsed number kept for existing consumers: the close record when\n   * the store wrote one, else the journal-derived sum. `totalUsdSource` names\n   * the pick, and says so when the number is a partial floor because some\n   * records carried `usdKnown: false`. Prefer `spend` — the collapse hides\n   * which accounting question the number answers and how much of it is priced.\n   */\n  readonly totalUsd: Measured<number>\n  /**\n   * Where `totalUsd` came from. CLI-backend workers never price their own inference into\n   * the journal, so on those arms the total is BRAIN-ONLY and the worker row's token\n   * counts (recovered from the harness store) are the honest worker-side figure.\n   */\n  readonly totalUsdSource: string\n  readonly costPerAcceptedPatchUsd: Measured<number>\n  readonly workerWallMsDistribution: Measured<WallDistribution>\n  readonly perWorker: Measured<readonly PerWorkerRow[]>\n}\n\nexport interface PatchStats {\n  readonly files: number\n  readonly linesAdded: number\n  readonly linesRemoved: number\n  readonly testFilesTouched: readonly string[]\n}\n\n/** Which record a run's terminal status was read from, so no source is a silent substitution. */\nexport type SupervisorStatusSource =\n  /** Runtime's `result.json` `kind`: the `SupervisedResult` discriminant, read verbatim. */\n  | 'runtime-result'\n  /** Runtime's `failure.json`: `supervise()` threw before a result landed. */\n  | 'runtime-failure'\n  /** Control-plane-era loops `state.json` `status`. */\n  | 'legacy-state'\n  /** Control-plane-era loops `result.json` `sup_status`. */\n  | 'legacy-result'\n\n/** The error a run directory recorded. */\nexport interface TerminalFailure {\n  /**\n   * Which record carried the error: Runtime's `failure.json`, or the driver\n   * rejection inside a `driver-failed` no-winner `result.json`.\n   */\n  readonly source: 'runtime-failure' | 'runtime-result'\n  /** `error.name` exactly as recorded; null when the record has none. */\n  readonly name: string | null\n  /** `error.message` exactly as recorded; null when the record has none. */\n  readonly message: string | null\n  /** ISO timestamp the record carries; null when it carries none. */\n  readonly at: string | null\n  /**\n   * True when the directory also holds a settled `result.json`. Runtime writes\n   * `failure.json` only when `supervise()` threw, never after a settle, and\n   * refuses to re-enter a settled directory, so a failure beside a result is\n   * the throw of an earlier attempt that a later attempt outlived. The status\n   * is the settled result's; this record explains the retry, not the outcome.\n   */\n  readonly earlierAttempt: boolean\n}\n\nexport interface OutcomeMetrics {\n  /**\n   * The run's terminal status, exactly as its record spells it: Runtime's\n   * `winner` / `no-winner`, `failed` for a Runtime failure record, or the\n   * legacy loops status. `supStatusSource` names the record it came from.\n   */\n  readonly supStatus: Measured<string>\n  readonly supStatusSource: Measured<SupervisorStatusSource>\n  /**\n   * Runtime's `reason` on a `no-winner` result (`all-children-down`,\n   * `budget-exhausted`, `aborted`, `driver-failed`). `null` = the terminal\n   * record carries no reason (a winner, a failure record, a legacy document).\n   */\n  readonly supReason: Measured<string | null>\n  /**\n   * The recorded error: Runtime's `failure.json`, or the driver rejection a\n   * `driver-failed` no-winner carries. `null` = the run recorded a result and\n   * no error. A `failure.json` beside a settled result is reported with\n   * `earlierAttempt: true`. Unavailable when the store has no terminal record.\n   */\n  readonly failure: Measured<TerminalFailure | null>\n  readonly supVerdict: Measured<string>\n  readonly delivered: Measured<boolean>\n  readonly judgeResolved: Measured<boolean | null>\n  readonly judgeScore: Measured<number | null>\n  readonly judgePassed: Measured<number | null>\n  readonly judgeTotal: Measured<number | null>\n  readonly verifyPass: Measured<boolean>\n  readonly verifyRc: Measured<number>\n  readonly patch: Measured<PatchStats>\n  /** Which document the judge fields came from (a judge file, a ledger row, or nothing). */\n  readonly judgeSource: string | null\n}\n\nexport interface SupervisorRunReport {\n  readonly schema: typeof SUPERVISOR_RUN_SCHEMA\n  /** The `runRef` of the sources this report was computed from. */\n  readonly runRef: string\n  readonly instanceId: string | null\n  readonly arm: string | null\n  readonly supervisorId: Measured<string>\n  readonly supervisorProfileDigest: Measured<string>\n  readonly generatedAt: string\n  readonly orchestration: OrchestrationMetrics\n  readonly decision: DecisionMetrics\n  readonly economics: EconomicsMetrics\n  readonly outcome: OutcomeMetrics\n  /** Artifacts that were missing, in read order — the provenance of every `unavailable`. */\n  readonly gaps: readonly string[]\n  /** The `traces` CLI command that covers the harness-session layer for this run. */\n  readonly traceCommand: string\n}\n\nexport interface RollupCellRow {\n  readonly instanceId: string | null\n  readonly arm: string | null\n  readonly steers: Measured<number>\n  readonly waves: Measured<number>\n  readonly utilization: Measured<number>\n  readonly idlePct: Measured<number>\n  readonly resolved: Measured<boolean | null>\n  readonly usd: Measured<number>\n}\n\nexport interface SupervisorRunRollup {\n  readonly schema: typeof SUPERVISOR_RUN_ROLLUP_SCHEMA\n  readonly cells: number\n  readonly steersTotal: Measured<number>\n  readonly cellsWithSteers: Measured<number>\n  readonly cellsWithUnavailableSteers: number\n  readonly wavesMean: Measured<number>\n  readonly maxConcurrencyMax: Measured<number>\n  readonly utilizationMean: Measured<number>\n  readonly idlePctMean: Measured<number>\n  readonly workersSpawnedTotal: Measured<number>\n  readonly acceptedTotal: Measured<number>\n  /**\n   * Sum of the per-run collapsed `totalUsd`. Prefer `spendUsd`: this total\n   * mixes close-record and journal-derived cells without saying which.\n   */\n  readonly usdTotal: Measured<number>\n  /**\n   * Fleet spend measured two ways. `runs` is each measurement's own\n   * denominator — the cells where that measurement was available. The two\n   * sums cover different run sets, so comparing the values without their\n   * denominators manufactures a phantom divergence.\n   */\n  readonly spendUsd: {\n    readonly journalDerived: { readonly value: Measured<number>; readonly runs: number }\n    readonly closeRecord: { readonly value: Measured<number>; readonly runs: number }\n  }\n  readonly resolvedCount: Measured<number>\n  readonly perCell: readonly RollupCellRow[]\n}\n\n/**\n * A supervision tree expressed in the canonical rollout row type: one\n * `RolloutLine` per invocation, joined by `parent_rollout_id`. The root row\n * carries `role: 'supervisor'`; nested supervisors retain that role and leaf\n * invocations carry `role: 'worker'`.\n */\nexport interface SupervisorRunTree {\n  readonly rootId: string | null\n  readonly nodes: readonly RolloutLine[]\n  /** Typed reasons a rollout field could not be recovered, in read order. */\n  readonly gaps: readonly SupervisorRunTreeGap[]\n}\n\n/** Stable machine-readable reasons emitted while minting a supervisor tree. */\nexport type SupervisorRunTreeGapCode =\n  | 'journal-unavailable'\n  | 'source-row-malformed'\n  | 'root-spawn-unavailable'\n  | 'root-reward-unavailable'\n  | 'child-reward-unavailable'\n  | 'node-role-unavailable'\n  | 'node-schema-invalid'\n\nexport interface SupervisorRunTreeGap {\n  readonly code: SupervisorRunTreeGapCode\n  readonly message: string\n  readonly nodeId?: string\n  readonly count?: number\n}\n","/**\n * The run's terminal record, read from the documents the store wrote when the\n * run ended. Runtime's own record outranks every other source: `result.json` is\n * the `SupervisedResult` that `supervise()` returned, verbatim, and its `kind`\n * is the run's status. `failure.json` is the record Runtime writes when\n * `supervise()` threw before a result landed. The control-plane-era loops\n * documents (`state.json` `status`, `result.json` `sup_status`) stay readable\n * as named legacy sources, so a report always says which record it read.\n *\n * Pure: takes already-parsed documents and returns `Measured` values. The\n * analyzer and the rollout minter share it so a run never has two statuses.\n */\n\nimport { asRecord } from './source-facts'\nimport {\n  type Measured,\n  type SupervisorStatusSource,\n  type TerminalFailure,\n  unavailable,\n} from './types'\n\n/** The reason every terminal field reads `unavailable` when no store wrote one. */\nexport const NO_TERMINAL_RECORD =\n  'no terminal record: Runtime result.json kind, Runtime failure.json, or legacy state.json / result.json status'\n\n/** The status reported for a run whose directory holds Runtime's failure record and no result. */\nexport const RUNTIME_FAILED_STATUS = 'failed'\n\nexport interface TerminalRecordInput {\n  /** Legacy loops `state.json`, parsed; null when absent. */\n  readonly state: Record<string, unknown> | null\n  /** `result.json`, parsed; Runtime's `SupervisedResult` or the legacy loops result. */\n  readonly result: Record<string, unknown> | null\n  /**\n   * Runtime's `failure.json`, parsed. `null` when the store was read and holds\n   * none; `undefined` when the store has no such document type.\n   */\n  readonly failure: Record<string, unknown> | null | undefined\n}\n\nexport interface TerminalRecord {\n  readonly supStatus: Measured<string>\n  readonly supStatusSource: Measured<SupervisorStatusSource>\n  /**\n   * Runtime's `reason` on a `no-winner` result. `null` when the record carries\n   * none (a winner, a failure record, or a legacy document).\n   */\n  readonly supReason: Measured<string | null>\n  /** The recorded error. `null` when the run recorded a result and no error. */\n  readonly failure: Measured<TerminalFailure | null>\n  /**\n   * True when the run recorded a delivered result (Runtime `winner`, legacy\n   * `completed`); false on every other recorded terminal state; null when no\n   * terminal record exists.\n   */\n  readonly completed: boolean | null\n}\n\nfunction str(value: unknown): string | null {\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nfunction errorRecord(\n  doc: Record<string, unknown>,\n  source: TerminalFailure['source'],\n  earlierAttempt: boolean,\n): TerminalFailure | null {\n  if (typeof doc.error !== 'object' || doc.error === null) return null\n  const error = asRecord(doc.error)\n  return {\n    source,\n    name: str(error.name),\n    message: str(error.message),\n    at: str(doc.at),\n    earlierAttempt,\n  }\n}\n\nexport function readTerminalRecord(input: TerminalRecordInput): TerminalRecord {\n  const { state, result } = input\n  const resultKind = str(result?.kind)\n  const settled = resultKind !== null && result !== null\n  const failureRecord =\n    input.failure === null || input.failure === undefined\n      ? null\n      : errorRecord(input.failure, 'runtime-failure', settled)\n\n  if (settled) {\n    // Runtime's settle record is the status. A failure record beside it is an\n    // earlier attempt's throw (Runtime never writes one after a settle), kept\n    // as the recorded error with `earlierAttempt` set; a `driver-failed`\n    // no-winner carries its own rejection instead.\n    return {\n      supStatus: resultKind,\n      supStatusSource: 'runtime-result',\n      supReason: str(result.reason),\n      failure: failureRecord ?? errorRecord(result, 'runtime-result', false),\n      completed: resultKind === 'winner',\n    }\n  }\n\n  if (failureRecord !== null) {\n    return {\n      supStatus: RUNTIME_FAILED_STATUS,\n      supStatusSource: 'runtime-failure',\n      supReason: null,\n      failure: failureRecord,\n      completed: false,\n    }\n  }\n  if (input.failure !== null && input.failure !== undefined) {\n    // The document exists but carries no `error` object. The run still ended in\n    // a failure; only the detail is missing, and it says so.\n    return {\n      supStatus: RUNTIME_FAILED_STATUS,\n      supStatusSource: 'runtime-failure',\n      supReason: null,\n      failure: unavailable('Runtime failure.json carries no error record'),\n      completed: false,\n    }\n  }\n\n  const legacyStateStatus = str(state?.status)\n  if (legacyStateStatus !== null) {\n    return {\n      supStatus: legacyStateStatus,\n      supStatusSource: 'legacy-state',\n      supReason: null,\n      failure: unavailable('legacy state.json records no failure document'),\n      completed: legacyStateStatus === 'completed',\n    }\n  }\n  const legacyResultStatus = str(result?.sup_status)\n  if (legacyResultStatus !== null) {\n    return {\n      supStatus: legacyResultStatus,\n      supStatusSource: 'legacy-result',\n      supReason: null,\n      failure: unavailable('legacy result.json records no failure document'),\n      completed: legacyResultStatus === 'completed',\n    }\n  }\n\n  return {\n    supStatus: unavailable(NO_TERMINAL_RECORD),\n    supStatusSource: unavailable(NO_TERMINAL_RECORD),\n    supReason: unavailable(NO_TERMINAL_RECORD),\n    failure: unavailable(NO_TERMINAL_RECORD),\n    completed: null,\n  }\n}\n"],"mappings":"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"}

package/dist/tool-groups-DAe1t6zb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-groups-DAe1t6zb.d.ts","names":[],"sources":["../src/analyst/tool-groups.ts"],"mappings":";;;;KAmBY;;;;;;;;;;;;;;;;;;;;iBAgDI,wBACd,OAAO,oBACP,OAAO,qBACN"}

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

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