@tangle-network/traces 0.10.2 → 0.11.0

package/dist/{chunk-LC66I5TE.js → chunk-JCI5YXNT.js}

@@ -14,8 +14,8 @@ function parseSince(value) {
   const m = value.match(/^(\d+)\s*([mhd])$/i);
   if (m) {
     const unit = m[2].toLowerCase();
-    const ms = unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
-    return Date.now() - Number(m[1]) * ms;
+    const ms2 = unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+    return Date.now() - Number(m[1]) * ms2;
   }
   const t = Date.parse(value);
   if (Number.isNaN(t)) throw new Error(`--since: expected 30m / 2h / 7d or an ISO date, got "${value}"`);
@@ -167,8 +167,8 @@ function serializeSpans(spans) {
 async function writeOtlpFile(spans, outPath) {
   const { mkdtemp: mkdtemp8, writeFile: writeFile9 } = await import("fs/promises");
   const { tmpdir: tmpdir7 } = await import("os");
-  const { join: join25 } = await import("path");
-  const path = outPath ?? join25(await mkdtemp8(join25(tmpdir7(), "traces-")), "spans.otlp.jsonl");
+  const { join: join28 } = await import("path");
+  const path = outPath ?? join28(await mkdtemp8(join28(tmpdir7(), "traces-")), "spans.otlp.jsonl");
   await writeFile9(path, serializeSpans(spans), "utf8");
   return path;
 }
@@ -2795,13 +2795,12 @@ var ClaudeAdapter = class {
       agents.push(agent);
     }
     const agentsById = /* @__PURE__ */ new Map();
+    const ambiguousAgentIds = /* @__PURE__ */ new Set();
     const childrenByParent = /* @__PURE__ */ new Map();
     for (const agent of agents) {
-      if (agentsById.has(agent.agentId)) {
-        throw new Error(`Duplicate Claude subagent id: ${agent.agentId}`);
-      }
-      agentsById.set(agent.agentId, agent);
-      if (agent.meta.parentAgentId) {
+      if (agentsById.has(agent.agentId)) ambiguousAgentIds.add(agent.agentId);
+      else agentsById.set(agent.agentId, agent);
+      if (agent.meta.parentAgentId && !ambiguousAgentIds.has(agent.meta.parentAgentId)) {
         const siblings = childrenByParent.get(agent.meta.parentAgentId) ?? [];
         siblings.push(agent);
         childrenByParent.set(agent.meta.parentAgentId, siblings);
@@ -4873,8 +4872,8 @@ import { readdir as readdir10, stat as stat9 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 import { join as join12 } from "path";
 var SERVICE8 = "opencode";
-function isoOf(ms) {
-  return new Date(ms ?? 0).toISOString();
+function isoOf(ms2) {
+  return new Date(ms2 ?? 0).toISOString();
 }
 function textOf7(parts) {
   return capText(
@@ -5729,7 +5728,7 @@ function extractAbsolutePaths(spans) {
 async function resolveRepoAttrs(cwd) {
   if (!cwd) return {};
   const attrs = { [ATTR.CWD]: cwd };
-  const basename14 = (() => {
+  const basename15 = (() => {
     const trimmed = cwd.replace(/\/+$/g, "");
     const idx = trimmed.lastIndexOf("/");
     const name = idx === -1 ? trimmed : trimmed.slice(idx + 1);
@@ -5751,7 +5750,7 @@ async function resolveRepoAttrs(cwd) {
     if (commit) attrs[ATTR.GIT_COMMIT] = commit;
   } catch {
   }
-  attrs[ATTR.SUBJECT_KEY] = basename14;
+  attrs[ATTR.SUBJECT_KEY] = basename15;
   return attrs;
 }
 async function repoCandidateForPath(path) {
@@ -6546,10 +6545,10 @@ async function readLinuxProcProcessTable() {
   const rows = await Promise.all(
     entries.filter((entry) => entry.isDirectory() && /^\d+$/.test(entry.name)).map(async (entry) => {
       try {
-        const stat14 = await readFile5(`/proc/${entry.name}/stat`, "utf8");
-        const commandEnd = stat14.lastIndexOf(")");
+        const stat16 = await readFile5(`/proc/${entry.name}/stat`, "utf8");
+        const commandEnd = stat16.lastIndexOf(")");
         if (commandEnd < 0) return void 0;
-        const fields = stat14.slice(commandEnd + 1).trim().split(/\s+/);
+        const fields = stat16.slice(commandEnd + 1).trim().split(/\s+/);
         const pid = Number(entry.name);
         const parentPid = Number(fields[1]);
         if (!Number.isSafeInteger(pid) || pid < 1 || !Number.isSafeInteger(parentPid) || parentPid < 0) {
@@ -7742,12 +7741,12 @@ function isoTime2(value) {
   if (typeof value === "string") {
     const trimmed = value.trim();
     const normalized = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(trimmed) ? `${trimmed.replace(" ", "T")}Z` : trimmed;
-    const ms = Date.parse(normalized);
-    return Number.isFinite(ms) ? new Date(ms).toISOString() : void 0;
+    const ms2 = Date.parse(normalized);
+    return Number.isFinite(ms2) ? new Date(ms2).toISOString() : void 0;
   }
   if (typeof value === "number" && Number.isFinite(value)) {
-    const ms = value < 1e10 ? value * 1e3 : value;
-    return new Date(ms).toISOString();
+    const ms2 = value < 1e10 ? value * 1e3 : value;
+    return new Date(ms2).toISOString();
   }
   return void 0;
 }
@@ -8446,7 +8445,7 @@ function addSessionFindings(index, findings) {
       refs: errorSessions.slice(0, 5).map((row) => row.session.path)
     });
   }
-  const largeSessions = sessions.map((row) => ({ row, tokens: row.metrics.inputTokens + row.metrics.outputTokens })).filter(({ tokens: tokens2 }) => tokens2 >= 5e5).sort((a, b) => b.tokens - a.tokens);
+  const largeSessions = sessions.map((row) => ({ row, tokens: row.metrics.inputTokens + row.metrics.outputTokens })).filter(({ tokens: tokens3 }) => tokens3 >= 5e5).sort((a, b) => b.tokens - a.tokens);
   if (largeSessions.length > 0) {
     const largest = largeSessions[0]?.tokens ?? 0;
     findings.push({
@@ -8455,7 +8454,7 @@ function addSessionFindings(index, findings) {
       area: "session",
       title: `${largeSessions.length} session(s) reported at least 500k summed tokens`,
       impact: largest,
-      evidence: largeSessions.slice(0, 5).map(({ row, tokens: tokens2 }) => `${sessionLabel(row)}: ${tokens2.toLocaleString()} reported summed tokens (${row.metrics.inputTokens.toLocaleString()} in, ${row.metrics.outputTokens.toLocaleString()} out)`),
+      evidence: largeSessions.slice(0, 5).map(({ row, tokens: tokens3 }) => `${sessionLabel(row)}: ${tokens3.toLocaleString()} reported summed tokens (${row.metrics.inputTokens.toLocaleString()} in, ${row.metrics.outputTokens.toLocaleString()} out)`),
       next: "Check whether these sessions need shorter handoffs, smaller files, split tasks, or clearer token accounting before optimizing anything else.",
       refs: largeSessions.slice(0, 5).map(({ row }) => row.session.path)
     });
@@ -10134,7 +10133,7 @@ import { createHash as createHash9 } from "crypto";
 var VERIFY_RE = /\b(test|tests|vitest|jest|pytest|go test|cargo test|tsc|typecheck|lint|biome|eslint|build|check:invariants|preflight)\b/i;
 var CHANGE_RE = /\b(apply_patch|edit|write|create|delete|rename|replace|update|git apply|sed -i|perl -pi|tee\s|cat\s+>)/i;
 var CLAIM_DONE_RE = /\b(done|fixed|complete|completed|implemented|merged|verified|all green|tests pass|ready|works now)\b/i;
-var sleep = (ms, signal) => new Promise((resolve7) => {
+var sleep = (ms2, signal) => new Promise((resolve7) => {
   if (signal?.aborted) {
     resolve7();
     return;
@@ -10146,7 +10145,7 @@ var sleep = (ms, signal) => new Promise((resolve7) => {
   const t = setTimeout(() => {
     signal?.removeEventListener("abort", onAbort);
     resolve7();
-  }, ms);
+  }, ms2);
   signal?.addEventListener("abort", onAbort, { once: true });
 });
 function hash(parts) {
@@ -10554,6 +10553,1085 @@ async function streamSessions(opts) {
   }
 }
 
+// src/supervisor-run-context.ts
+import { readFile as readFile10, stat as stat13 } from "fs/promises";
+import { basename as basename13, join as join22 } from "path";
+import { materializeTreeView } from "@tangle-network/agent-runtime/kernel";
+import {
+  NO_SOURCE_LIMITS
+} from "@tangle-network/agent-eval/supervisor-run";
+var SPAWN_JOURNAL_FILE = "spawn-journal.jsonl";
+var COORDINATION_LOG_FILE = "coordination-log.jsonl";
+var RESULT_FILE = "result.json";
+var BLOBS_DIR = "blobs";
+async function readMaybe(path) {
+  return readFile10(path, "utf8").catch(() => null);
+}
+function readJsonlLines(text2) {
+  if (text2 === null) {
+    return { rows: [], invalidRows: 0, partialTail: false, present: false };
+  }
+  const lines = text2.split("\n");
+  const partialTail = text2.length > 0 && !text2.endsWith("\n");
+  if (partialTail) lines.pop();
+  const rows = [];
+  let invalidRows = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        rows.push(parsed);
+      } else invalidRows += 1;
+    } catch {
+      invalidRows += 1;
+    }
+  }
+  return { rows, invalidRows, partialTail, present: true };
+}
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function readRunContextJournal(text2) {
+  const parsed = readJsonlLines(text2);
+  let root = null;
+  let begunAt = null;
+  const events = [];
+  let invalidRows = parsed.invalidRows;
+  for (const record2 of parsed.rows) {
+    const recordRoot = str(record2.root);
+    if (root === null && recordRoot !== null) root = recordRoot;
+    if (record2.kind === "begin") {
+      if (begunAt === null) begunAt = str(record2.at);
+      continue;
+    }
+    if (record2.kind !== "event") {
+      invalidRows += 1;
+      continue;
+    }
+    const event = asRecord(record2.event);
+    if (str(event.kind) === null || str(event.id) === null) {
+      invalidRows += 1;
+      continue;
+    }
+    events.push(event);
+  }
+  const supervisorIds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.kind !== "spawned" && event.kind !== "waiting") continue;
+    const parent = event.parent;
+    if (typeof parent === "string" && parent.length > 0) supervisorIds.add(parent);
+  }
+  return {
+    root,
+    begunAt,
+    events,
+    supervisorIds,
+    invalidRows,
+    partialTail: parsed.partialTail,
+    present: parsed.present
+  };
+}
+function inferRole(id, parent, supervisorIds) {
+  if (parent === null || parent === void 0) return "supervisor";
+  return supervisorIds.has(id) ? "supervisor" : "worker";
+}
+var EMPTY_COORDINATION = {
+  present: false,
+  steers: [],
+  deliveries: [],
+  questions: [],
+  invalidRows: 0,
+  partialTail: false
+};
+function readCoordinationLog(text2) {
+  const parsed = readJsonlLines(text2);
+  if (!parsed.present) return EMPTY_COORDINATION;
+  const steers = [];
+  const deliveries = [];
+  const questions = [];
+  let invalidRows = parsed.invalidRows;
+  for (const row of parsed.rows) {
+    const record2 = asRecord(row.record);
+    const event = asRecord(Object.keys(record2).length > 0 ? record2.event : row.event);
+    const at = typeof record2.at === "number" ? record2.at : parseInstant(row.at);
+    switch (event.type) {
+      case "steer": {
+        const down = asRecord(event.down);
+        steers.push({
+          messageId: str(down.messageId),
+          toWorker: str(down.toWorker),
+          instruction: typeof down.instruction === "string" ? down.instruction : "",
+          deliveryMode: str(down.deliveryMode),
+          at
+        });
+        break;
+      }
+      case "delivery": {
+        const receipt = asRecord(event.receipt);
+        deliveries.push({
+          messageId: str(receipt.messageId),
+          delivered: typeof receipt.delivered === "boolean" ? receipt.delivered : null
+        });
+        break;
+      }
+      case "question": {
+        const q = asRecord(event.question);
+        const urgency = str(q.urgency);
+        questions.push({
+          id: str(q.id),
+          from: str(q.from),
+          question: typeof q.question === "string" ? q.question : "",
+          reason: str(q.reason),
+          urgency,
+          status: str(q.status),
+          blocking: urgency === "blocks-run",
+          at: typeof q.openedAt === "number" ? q.openedAt : at
+        });
+        break;
+      }
+      case "settled":
+        break;
+      default:
+        if (str(event.type) === null) invalidRows += 1;
+    }
+  }
+  return {
+    present: true,
+    steers,
+    deliveries,
+    questions,
+    invalidRows,
+    partialTail: parsed.partialTail
+  };
+}
+function parseInstant(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v !== "string") return null;
+  const t = Date.parse(v);
+  return Number.isFinite(t) ? t : null;
+}
+async function readFileRunContext(runDir, opts = {}) {
+  const journalText = await readMaybe(join22(runDir, SPAWN_JOURNAL_FILE));
+  const journal = readRunContextJournal(journalText);
+  const coordination = readCoordinationLog(await readMaybe(join22(runDir, COORDINATION_LOG_FILE)));
+  const result = await readMaybe(join22(runDir, RESULT_FILE));
+  return {
+    runRef: runDir,
+    instanceId: opts.instanceId !== void 0 ? opts.instanceId : journal.root,
+    arm: opts.arm !== void 0 ? opts.arm : basename13(runDir),
+    // The journal is the store, and it lives directly in the run directory —
+    // this layout has no separate supervisor sub-directory.
+    supRunDir: journal.present ? runDir : null,
+    journal: journal.present ? flattenJournal(journal) : null,
+    // Per-brain-call taps and progress streams are loops artifacts; this layout
+    // writes neither, so truncation genuinely cannot be ruled out.
+    brainLog: null,
+    state: journal.present ? runState(journal, result) : null,
+    progress: null,
+    ...workerSources(journal, coordination),
+    result,
+    judge: null,
+    judgeSource: null,
+    patch: null,
+    driverLog: null,
+    harnessWorkerTokens: null,
+    harnessMissingReason: "the file run context journals each child\u2019s own settled spend, so no external harness join is used",
+    limits: sourceLimits(journal, coordination),
+    rootTranscriptRef: journal.present ? join22(runDir, SPAWN_JOURNAL_FILE) : null,
+    traceCommand: `traces watch ${runDir}`
+  };
+}
+function fileRunContextSupervisorRunReader(runDir, opts = {}) {
+  return { runRef: runDir, read: () => readFileRunContext(runDir, opts) };
+}
+async function isFileRunContextDir(runDir) {
+  return stat13(join22(runDir, SPAWN_JOURNAL_FILE)).then((s) => s.isFile()).catch(() => false);
+}
+function flattenJournal(journal) {
+  return journal.events.map((event) => {
+    if (event.kind !== "spawned") return JSON.stringify(event);
+    return JSON.stringify({
+      ...event,
+      role: inferRole(event.id, event.parent, journal.supervisorIds)
+    });
+  }).join("\n");
+}
+function runState(journal, resultText) {
+  const result = parseJsonObject(resultText);
+  const state = {};
+  if (journal.begunAt !== null) state.startedAt = journal.begunAt;
+  if (result !== null) {
+    const kind = str(result.kind);
+    const reason = str(result.reason);
+    if (kind !== null) state.status = kind;
+    if (reason !== null) state.verdict = reason;
+    const spentTotal = asRecord(result.spentTotal);
+    if (typeof spentTotal.usd === "number" && spentTotal.usdKnown !== false) {
+      state.result = { spentUsd: spentTotal.usd };
+    }
+  }
+  return JSON.stringify(state);
+}
+function parseJsonObject(text2) {
+  if (text2 === null) return null;
+  try {
+    const parsed = JSON.parse(text2);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function workerSources(journal, coordination) {
+  if (!journal.present) {
+    return { workers: null, workersMissingReason: `${SPAWN_JOURNAL_FILE} absent` };
+  }
+  const view = safeTreeView(journal.events);
+  if (view === null) {
+    return { workers: null, workersMissingReason: "spawn journal could not be folded into a tree" };
+  }
+  const deliveredById = /* @__PURE__ */ new Map();
+  for (const receipt of coordination.deliveries) {
+    if (receipt.messageId !== null) deliveredById.set(receipt.messageId, receipt.delivered);
+  }
+  const spendById = settledSpendById(journal.events);
+  const workers = [];
+  for (const node of view.nodes) {
+    if (node.parent === void 0) continue;
+    const steers = coordination.steers.filter((s) => s.toWorker === node.id);
+    const questions = coordination.questions.filter((q) => q.from === node.id);
+    const spend = spendById.get(node.id) ?? null;
+    workers.push({
+      workerId: node.id,
+      label: node.label,
+      events: coordination.present ? [
+        ...steers.map(
+          (s) => JSON.stringify({
+            kind: "message",
+            requestId: s.messageId,
+            delivered: s.messageId === null ? null : deliveredById.get(s.messageId) ?? null
+          })
+        ),
+        ...questions.map((q) => JSON.stringify({ kind: "message", direction: "up", id: q.id }))
+      ].join("\n") : null,
+      inbox: coordination.present ? steers.map((s) => JSON.stringify({ id: s.messageId, message: s.instruction })).join("\n") : null,
+      // Content-addressed result blobs are not patches; this layout retains no
+      // per-worker diff, so byte counts would be a fabricated zero.
+      patchBytes: null,
+      transcriptRef: null,
+      patchPath: null,
+      tokensIn: spend?.tokens.input ?? null,
+      tokensOut: spend?.tokens.output ?? null
+    });
+  }
+  return { workers, workersMissingReason: null };
+}
+function settledSpendById(events) {
+  const out = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind !== "settled") continue;
+    out.set(event.id, event.spent);
+  }
+  return out;
+}
+function sourceLimits(journal, coordination) {
+  const unpriced = unpricedNodes(journal.events);
+  const verdicts = journal.events.filter(
+    (event) => event.kind === "settled" && event.verdict !== void 0
+  ).length;
+  const settlements = journal.events.filter((event) => event.kind === "settled").length;
+  return {
+    ...NO_SOURCE_LIMITS,
+    // Both are journaled per node: `metered` for a driver's own inference,
+    // `settled.spent` for what a child consumed.
+    managerTokens: null,
+    workerTokens: null,
+    spendUsd: unpriced.length === 0 ? null : `${unpriced.length} spend record(s) carry usdKnown:false (${unpriced.slice(0, 4).join(", ")}${unpriced.length > 4 ? ", \u2026" : ""}) \u2014 the run\u2019s dollar total is unknown, not $0`,
+    workerVerdicts: settlements === 0 || verdicts > 0 ? null : "no settled event carried a verdict; this layout records a done/down status only",
+    deliverables: `${BLOBS_DIR}/ holds content-addressed result artifacts, not patches`
+  };
+}
+function unpricedNodes(events) {
+  const ids = [];
+  for (const event of events) {
+    const spend = event.kind === "settled" ? event.spent : event.kind === "metered" ? event.spend : null;
+    if (spend?.usdKnown === false) ids.push(event.id);
+  }
+  return [...new Set(ids)];
+}
+var ZERO_ROLL = {
+  records: 0,
+  iterations: 0,
+  tokensIn: 0,
+  tokensOut: 0,
+  usd: 0,
+  usdKnownRecords: 0,
+  usdUnknownRecords: 0
+};
+function addSpend(roll, spend) {
+  const known = spend.usdKnown !== false;
+  return {
+    records: roll.records + 1,
+    iterations: roll.iterations + (spend.iterations ?? 0),
+    tokensIn: roll.tokensIn + (spend.tokens?.input ?? 0),
+    tokensOut: roll.tokensOut + (spend.tokens?.output ?? 0),
+    usd: roll.usd + (known ? spend.usd ?? 0 : 0),
+    usdKnownRecords: roll.usdKnownRecords + (known ? 1 : 0),
+    usdUnknownRecords: roll.usdUnknownRecords + (known ? 0 : 1)
+  };
+}
+function mergeRolls(a, b) {
+  return {
+    records: a.records + b.records,
+    iterations: a.iterations + b.iterations,
+    tokensIn: a.tokensIn + b.tokensIn,
+    tokensOut: a.tokensOut + b.tokensOut,
+    usd: a.usd + b.usd,
+    usdKnownRecords: a.usdKnownRecords + b.usdKnownRecords,
+    usdUnknownRecords: a.usdUnknownRecords + b.usdUnknownRecords
+  };
+}
+async function readRunContextSnapshot(runDir) {
+  const journal = readRunContextJournal(await readMaybe(join22(runDir, SPAWN_JOURNAL_FILE)));
+  const coordination = readCoordinationLog(await readMaybe(join22(runDir, COORDINATION_LOG_FILE)));
+  const resultText = await readMaybe(join22(runDir, RESULT_FILE));
+  const result = parseResult(resultText);
+  const view = safeTreeView(journal.events);
+  const nodes = view === null ? [] : orderNodes(view, journal);
+  return {
+    runDir,
+    runId: journal.root,
+    present: journal.present,
+    nodes,
+    maxDepth: nodes.reduce((max, n) => Math.max(max, n.depth), 0),
+    begunAt: parseInstant(journal.begunAt),
+    lastEventAt: journal.events.reduce((latest, event) => {
+      const at = parseInstant(event.at);
+      return at === null ? latest : latest === null ? at : Math.max(latest, at);
+    }, null),
+    questions: coordination.questions,
+    steers: coordination.steers,
+    result,
+    terminal: resultText !== null,
+    invalidJournalRows: journal.invalidRows,
+    invalidCoordinationRows: coordination.invalidRows,
+    partialTail: journal.partialTail || coordination.partialTail,
+    treeError: view === null && journal.present ? "spawn journal could not be folded into a tree (a settle or cancel names a node that was never spawned)" : null
+  };
+}
+function safeTreeView(events) {
+  if (events.length === 0) return null;
+  try {
+    return materializeTreeView([...events]);
+  } catch {
+    return null;
+  }
+}
+function orderNodes(view, journal) {
+  const driver = /* @__PURE__ */ new Map();
+  const settled = /* @__PURE__ */ new Map();
+  const childRoll = /* @__PURE__ */ new Map();
+  const spawnedAt = /* @__PURE__ */ new Map();
+  const settledAt = /* @__PURE__ */ new Map();
+  const cancelReason = /* @__PURE__ */ new Map();
+  const parentOf = new Map(view.nodes.map((n) => [n.id, n.parent]));
+  for (const event of journal.events) {
+    const at = parseInstant(event.at);
+    if (event.kind === "spawned" || event.kind === "waiting") {
+      spawnedAt.set(event.id, at);
+    } else if (event.kind === "metered") {
+      driver.set(event.id, addSpend(driver.get(event.id) ?? ZERO_ROLL, event.spend));
+    } else if (event.kind === "settled") {
+      settled.set(event.id, addSpend(settled.get(event.id) ?? ZERO_ROLL, event.spent));
+      settledAt.set(event.id, at);
+      const parent = parentOf.get(event.id);
+      if (parent !== void 0) {
+        childRoll.set(parent, addSpend(childRoll.get(parent) ?? ZERO_ROLL, event.spent));
+      }
+    } else if (event.kind === "cancelled") {
+      settledAt.set(event.id, at);
+      cancelReason.set(event.id, event.reason);
+    } else if (event.kind === "woken") {
+      settledAt.set(event.id, at);
+    }
+  }
+  const byParent = /* @__PURE__ */ new Map();
+  for (const node of view.nodes) {
+    const key = node.parent ?? null;
+    const bucket = byParent.get(key);
+    if (bucket) bucket.push(node);
+    else byParent.set(key, [node]);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (id, depth) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const node = view.nodes.find((n) => n.id === id);
+    if (node === void 0) return;
+    const spawned = spawnedAt.get(id) ?? null;
+    const closed = settledAt.get(id) ?? null;
+    out.push({
+      id: node.id,
+      parent: node.parent ?? null,
+      label: node.label,
+      depth,
+      role: inferRole(node.id, node.parent, journal.supervisorIds),
+      status: node.status,
+      runtime: node.runtime ?? null,
+      budget: node.budget,
+      driver: driver.get(id) ?? ZERO_ROLL,
+      children: childRoll.get(id) ?? ZERO_ROLL,
+      settled: settled.get(id) ?? ZERO_ROLL,
+      spawnedAt: spawned,
+      settledAt: closed,
+      wallMs: spawned !== null && closed !== null ? closed - spawned : null,
+      outRef: node.outRef ?? null,
+      cancelReason: cancelReason.get(id) ?? null
+    });
+    for (const child of byParent.get(id) ?? []) walk(child.id, depth + 1);
+  };
+  walk(view.root, 0);
+  for (const node of view.nodes) if (!seen.has(node.id)) walk(node.id, 0);
+  return out;
+}
+function parseResult(text2) {
+  const result = parseJsonObject(text2);
+  if (result === null) return null;
+  const error = asRecord(result.error);
+  return {
+    kind: str(result.kind),
+    reason: str(result.reason),
+    errorName: str(error.name),
+    errorMessage: str(error.message)
+  };
+}
+
+// src/run-view-format.ts
+var RULE = "\u2500".repeat(76);
+function int(n) {
+  return n.toLocaleString("en-US");
+}
+function ms(value) {
+  if (value === null) return "\u2014";
+  if (value < 1e3) return `${value}ms`;
+  if (value < 6e4) return `${(value / 1e3).toFixed(1)}s`;
+  const minutes = Math.floor(value / 6e4);
+  return `${minutes}m${String(Math.round(value % 6e4 / 1e3)).padStart(2, "0")}s`;
+}
+function usd(roll) {
+  if (roll.usdKnownRecords === 0) {
+    return roll.usdUnknownRecords === 0 ? "no spend recorded" : `cost unknown (${roll.usdUnknownRecords} unpriced)`;
+  }
+  const priced = zeroPricedCost(roll) ? `$${roll.usd.toFixed(4)} (zero across ${roll.usdKnownRecords} priced)` : `$${roll.usd.toFixed(4)}`;
+  return roll.usdUnknownRecords === 0 ? priced : `${priced} + ${roll.usdUnknownRecords} unpriced`;
+}
+function zeroPricedCost(roll) {
+  return roll.usdKnownRecords > 0 && roll.usd === 0 && roll.tokensIn + roll.tokensOut > 0;
+}
+function tokens2(roll) {
+  return `in ${int(roll.tokensIn)} \xB7 out ${int(roll.tokensOut)}`;
+}
+var STATUS_MARK = {
+  pending: "\xB7",
+  acquiring: "\u25D0",
+  running: "\u25B6",
+  waiting: "\u23F8",
+  done: "\u2713",
+  failed: "\u2717",
+  cancelled: "\u2298"
+};
+function connectors(depth, lastAtDepth) {
+  if (depth === 0) return { head: "\u25CF ", detail: "    " };
+  let stem = "";
+  for (let level = 1; level < depth; level++) stem += lastAtDepth[level] ? "   " : "\u2502  ";
+  const isLast = lastAtDepth[depth] ?? true;
+  return { head: `${stem}${isLast ? "\u2514\u2500 " : "\u251C\u2500 "}`, detail: `${stem}${isLast ? "   " : "\u2502  "}    ` };
+}
+function forEachTreeNode(nodes, parentKey, selfKey, visit) {
+  const lastChildOf = /* @__PURE__ */ new Map();
+  for (const node of nodes) lastChildOf.set(parentKey(node), selfKey(node));
+  const lastAtDepth = [];
+  for (const node of nodes) {
+    lastAtDepth[node.depth] = lastChildOf.get(parentKey(node)) === selfKey(node);
+    lastAtDepth.length = node.depth + 1;
+    visit(node, lastAtDepth);
+  }
+}
+function wrap(text2, indent) {
+  const width = Math.max(40, (process.stdout.columns ?? 100) - indent - 2);
+  const pad = " ".repeat(indent);
+  const out = [];
+  for (const paragraph of text2.split("\n")) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      if (line.length > 0 && line.length + 1 + word.length > width) {
+        out.push(pad + line);
+        line = word;
+      } else line = line.length === 0 ? word : `${line} ${word}`;
+    }
+    out.push(pad + line);
+  }
+  return out;
+}
+
+// src/run-span-tree.ts
+import { readdir as readdir15 } from "fs/promises";
+import { join as join23 } from "path";
+import {
+  firstNumberAttr as firstNumberAttr2,
+  LLM_COST_ATTR_KEYS as LLM_COST_ATTR_KEYS2,
+  LLM_INPUT_TOKEN_ATTR_KEYS as LLM_INPUT_TOKEN_ATTR_KEYS2,
+  LLM_OUTPUT_TOKEN_ATTR_KEYS as LLM_OUTPUT_TOKEN_ATTR_KEYS2,
+  SPAN_KIND_ATTR_KEYS
+} from "@tangle-network/agent-eval/trace-attributes";
+var AGENT_NAME_ATTR_KEYS = ["agent.name", "inference.agent_name", "gen_ai.agent.name"];
+var SERVICE_NAME_ATTR_KEYS = ["service.name", "tangle.runtime"];
+var AGENT_OPERATIONS = /* @__PURE__ */ new Set(["invoke_agent", "invoke_workflow"]);
+var OPERATION_ATTR_KEY = "gen_ai.operation.name";
+function firstStringAttr(attributes, keys) {
+  for (const key of keys) {
+    const value = attributes[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return null;
+}
+var EMPTY_SPAN_RUN_SNAPSHOT = {
+  present: false,
+  nodes: [],
+  maxDepth: 0,
+  traceIds: [],
+  spanCount: 0,
+  startMs: null,
+  endMs: null,
+  llmSpansWithoutTokens: 0,
+  llmSpansWithoutCost: 0,
+  orphanSpans: 0,
+  readError: null
+};
+function spanKind3(span2) {
+  return firstStringAttr(span2.attributes, SPAN_KIND_ATTR_KEYS);
+}
+function isNodeBoundary(span2, enclosingNodeId, enclosingAgent) {
+  if (span2.parent_span_id === null || enclosingNodeId === null) return true;
+  if (spanKind3(span2) === "AGENT") return true;
+  if (AGENT_OPERATIONS.has(String(span2.attributes[OPERATION_ATTR_KEY] ?? ""))) return true;
+  const agent = firstStringAttr(span2.attributes, AGENT_NAME_ATTR_KEYS);
+  return agent !== null && enclosingAgent !== null && agent !== enclosingAgent;
+}
+function spanSpend(span2) {
+  const cost = firstNumberAttr2(span2.attributes, LLM_COST_ATTR_KEYS2);
+  return {
+    iterations: 0,
+    tokens: {
+      input: firstNumberAttr2(span2.attributes, LLM_INPUT_TOKEN_ATTR_KEYS2) ?? 0,
+      output: firstNumberAttr2(span2.attributes, LLM_OUTPUT_TOKEN_ATTR_KEYS2) ?? 0
+    },
+    usd: cost ?? 0,
+    ...cost === null ? { usdKnown: false } : {},
+    ms: 0
+  };
+}
+function epoch(value) {
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function buildSpanRunTree(spans, source) {
+  if (spans.length === 0) return { ...EMPTY_SPAN_RUN_SNAPSHOT, source };
+  const byId = /* @__PURE__ */ new Map();
+  for (const span2 of spans) byId.set(spanKey(span2), span2);
+  const childrenOf = /* @__PURE__ */ new Map();
+  let orphanSpans = 0;
+  for (const span2 of spans) {
+    const parentKey = span2.parent_span_id === null ? null : byId.has(`${span2.trace_id}\0${span2.parent_span_id}`) ? `${span2.trace_id}\0${span2.parent_span_id}` : null;
+    if (span2.parent_span_id !== null && parentKey === null) orphanSpans += 1;
+    const bucket = childrenOf.get(parentKey);
+    if (bucket) bucket.push(span2);
+    else childrenOf.set(parentKey, [span2]);
+  }
+  for (const bucket of childrenOf.values()) {
+    bucket.sort((a, b) => epoch(a.start_time) - epoch(b.start_time) || a.span_id.localeCompare(b.span_id));
+  }
+  const building = /* @__PURE__ */ new Map();
+  const order = [];
+  let llmSpansWithoutTokens = 0;
+  let llmSpansWithoutCost = 0;
+  const walk = (span2, enclosingNodeId, enclosingAgent, depth) => {
+    const key = spanKey(span2);
+    const agent = firstStringAttr(span2.attributes, AGENT_NAME_ATTR_KEYS) ?? enclosingAgent;
+    let nodeId = enclosingNodeId;
+    let nodeAgent = enclosingAgent;
+    let childDepth = depth;
+    if (isNodeBoundary(span2, enclosingNodeId, enclosingAgent)) {
+      const node = {
+        span: span2,
+        parentNodeId: enclosingNodeId,
+        depth,
+        agent,
+        driver: ZERO_ROLL,
+        toolCalls: 0,
+        startMs: epoch(span2.start_time),
+        endMs: epoch(span2.end_time),
+        errors: [],
+        childNodeIds: []
+      };
+      building.set(key, node);
+      order.push(key);
+      if (enclosingNodeId !== null) building.get(enclosingNodeId)?.childNodeIds.push(key);
+      nodeId = key;
+      nodeAgent = agent;
+      childDepth = depth + 1;
+    }
+    const host = nodeId === null ? void 0 : building.get(nodeId);
+    if (host !== void 0) {
+      const kind = spanKind3(span2);
+      if (kind === "LLM") {
+        host.driver = addSpend(host.driver, spanSpend(span2));
+        if (firstNumberAttr2(span2.attributes, LLM_INPUT_TOKEN_ATTR_KEYS2) === null && firstNumberAttr2(span2.attributes, LLM_OUTPUT_TOKEN_ATTR_KEYS2) === null) {
+          llmSpansWithoutTokens += 1;
+        }
+        if (firstNumberAttr2(span2.attributes, LLM_COST_ATTR_KEYS2) === null) llmSpansWithoutCost += 1;
+      } else if (kind === "TOOL") host.toolCalls += 1;
+      host.startMs = Math.min(host.startMs, epoch(span2.start_time));
+      host.endMs = Math.max(host.endMs, epoch(span2.end_time));
+      if (span2.status.code === "ERROR") {
+        host.errors.push(`${span2.name}: ${span2.status.message ?? "ERROR"}`);
+      }
+    }
+    for (const child of childrenOf.get(key) ?? []) walk(child, nodeId, nodeAgent, childDepth);
+  };
+  for (const root of childrenOf.get(null) ?? []) walk(root, null, null, 0);
+  const subtotal = /* @__PURE__ */ new Map();
+  const subtotalOf = (key) => {
+    const cached = subtotal.get(key);
+    if (cached !== void 0) return cached;
+    const node = building.get(key);
+    if (node === void 0) return ZERO_ROLL;
+    subtotal.set(key, ZERO_ROLL);
+    let total = node.driver;
+    for (const child of node.childNodeIds) total = mergeRolls(total, subtotalOf(child));
+    subtotal.set(key, total);
+    return total;
+  };
+  const nodes = order.map((key) => {
+    const node = building.get(key);
+    let children = ZERO_ROLL;
+    for (const child of node.childNodeIds) children = mergeRolls(children, subtotalOf(child));
+    return {
+      traceId: node.span.trace_id,
+      spanId: node.span.span_id,
+      parentNodeId: node.parentNodeId === null ? null : building.get(node.parentNodeId).span.span_id,
+      label: node.agent ?? node.span.name,
+      depth: node.depth,
+      role: node.childNodeIds.length > 0 ? "driver" : "leaf",
+      status: node.errors.length > 0 || node.span.status.code === "ERROR" ? "failed" : node.span.status.code === "UNSET" ? "running" : "done",
+      runtime: firstStringAttr(node.span.attributes, SERVICE_NAME_ATTR_KEYS),
+      driver: node.driver,
+      children,
+      toolCalls: node.toolCalls,
+      startMs: node.startMs,
+      endMs: node.endMs,
+      wallMs: Math.max(0, node.endMs - node.startMs),
+      errors: node.errors
+    };
+  });
+  return {
+    source,
+    present: true,
+    nodes,
+    maxDepth: nodes.reduce((max, n) => Math.max(max, n.depth), 0),
+    traceIds: [...new Set(spans.map((s) => s.trace_id))],
+    spanCount: spans.length,
+    startMs: nodes.reduce((min, n) => min === null ? n.startMs : Math.min(min, n.startMs), null),
+    endMs: nodes.reduce((max, n) => max === null ? n.endMs : Math.max(max, n.endMs), null),
+    llmSpansWithoutTokens,
+    llmSpansWithoutCost,
+    orphanSpans,
+    readError: null
+  };
+}
+function spanKey(span2) {
+  return `${span2.trace_id}\0${span2.span_id}`;
+}
+async function readSpanRunSnapshot(path) {
+  try {
+    const exported = await exportTraceEvidenceFile(path);
+    return buildSpanRunTree(exported.spans, path);
+  } catch (error) {
+    return {
+      ...EMPTY_SPAN_RUN_SNAPSHOT,
+      source: path,
+      readError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function spanRunTotals(snapshot) {
+  let driver = ZERO_ROLL;
+  let leaves = ZERO_ROLL;
+  for (const node of snapshot.nodes) {
+    if (node.role === "driver") driver = mergeRolls(driver, node.driver);
+    else leaves = mergeRolls(leaves, node.driver);
+  }
+  return { driver, leaves };
+}
+function renderSpanRunSnapshot(snapshot) {
+  const lines = [];
+  lines.push(`spans ${snapshot.source}`);
+  if (snapshot.readError !== null) {
+    lines.push(`  unreadable: ${snapshot.readError}`);
+    return lines.join("\n");
+  }
+  if (!snapshot.present || snapshot.nodes.length === 0) {
+    lines.push("  no spans yet \u2014 the emitter has written nothing this view can place");
+    return lines.join("\n");
+  }
+  const totals = spanRunTotals(snapshot);
+  lines.push(
+    `  ${snapshot.nodes.length} node(s) \xB7 depth ${snapshot.maxDepth} \xB7 ${int(snapshot.spanCount)} span(s) \xB7 ${snapshot.traceIds.length} trace(s) \xB7 elapsed ${ms(snapshot.endMs === null || snapshot.startMs === null ? null : snapshot.endMs - snapshot.startMs)}`
+  );
+  const delegating = snapshot.nodes.some((node) => node.role === "driver");
+  lines.push(`  driver inference  ${tokens2(totals.driver)} \xB7 ${usd(totals.driver)}`);
+  lines.push(`  leaf inference    ${tokens2(totals.leaves)} \xB7 ${usd(totals.leaves)}`);
+  if (!delegating) {
+    lines.push("  (no delegation in these spans: every turn belongs to one agent, so the driver half is empty)");
+  }
+  lines.push("");
+  forEachTreeNode(
+    snapshot.nodes,
+    (n) => n.parentNodeId,
+    (n) => n.spanId,
+    (node, lastAtDepth) => {
+      const { head: prefix, detail } = connectors(node.depth, lastAtDepth);
+      const mark = node.status === "failed" ? "\u2717" : node.status === "running" ? "\u25B6" : "\u2713";
+      lines.push(
+        [
+          `${prefix}${mark} ${node.label}`,
+          `[${node.status}]`,
+          node.role,
+          node.runtime ?? "no-runtime",
+          "budget not in spans",
+          `wall ${ms(node.wallMs)}`
+        ].join("  ")
+      );
+      lines.push(
+        `${detail}driver    ${node.driver.records} turn(s) \xB7 ${tokens2(node.driver)} \xB7 ${usd(node.driver)} \xB7 ${node.toolCalls} tool call(s)`
+      );
+      if (node.role === "driver") {
+        lines.push(
+          `${detail}children  ${node.children.records} turn(s) \xB7 ${tokens2(node.children)} \xB7 ${usd(node.children)}`
+        );
+      }
+      for (const error of node.errors.slice(0, 3)) lines.push(`${detail}error ${error}`);
+    }
+  );
+  const problems = [];
+  if (snapshot.llmSpansWithoutCost > 0) {
+    problems.push(
+      `${snapshot.llmSpansWithoutCost} of the LLM span(s) carry no cost attribute \u2014 that spend is UNKNOWN, not $0 (this emitter writes tokens without a price)`
+    );
+  }
+  if (snapshot.llmSpansWithoutTokens > 0) {
+    problems.push(`${snapshot.llmSpansWithoutTokens} LLM span(s) carry no token count`);
+  }
+  if (snapshot.orphanSpans > 0) {
+    problems.push(
+      `${snapshot.orphanSpans} span(s) name a parent_span_id absent from this file \u2014 re-rooted, not dropped`
+    );
+  }
+  problems.push(
+    "spans carry no authored budget in either the OpenInference or the GenAI vocabulary; point this at a run directory with a spawn journal to see ceilings and settlement"
+  );
+  lines.push("");
+  for (const problem of problems) lines.push(`  ! ${problem}`);
+  return lines.join("\n");
+}
+var SPAN_FILE_PATTERN = /\.(?:otlp|spans|traces|openinference)\.(?:jsonl|ndjson)$|^traces?\.jsonl$|^spans\.jsonl$/i;
+async function findSpanSourceFiles(dir) {
+  const found = [];
+  const entries = await readdir15(dir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    const child = join23(dir, entry.name);
+    if (entry.isFile()) {
+      if (SPAN_FILE_PATTERN.test(entry.name)) found.push(child);
+      continue;
+    }
+    if (!entry.isDirectory()) continue;
+    const nested = await readdir15(child, { withFileTypes: true }).catch(() => []);
+    for (const inner of nested) {
+      if (inner.isFile() && SPAN_FILE_PATTERN.test(inner.name)) found.push(join23(child, inner.name));
+    }
+  }
+  return found.sort();
+}
+
+// src/supervisor-run-watch.ts
+import { readdir as readdir16 } from "fs/promises";
+import { join as join24 } from "path";
+function budget(node) {
+  const parts = [`${int(node.budget.maxIterations)}it`, `${int(node.budget.maxTokens)}tok`];
+  if (node.budget.maxUsd !== void 0) parts.push(`$${node.budget.maxUsd.toFixed(2)}`);
+  if (node.budget.deadlineMs !== void 0) parts.push(ms(node.budget.deadlineMs));
+  return parts.join("/");
+}
+function budgetUse(node, spent) {
+  const parts = [];
+  if (node.budget.maxIterations > 0 && spent.iterations > 0) {
+    parts.push(`${Math.round(spent.iterations / node.budget.maxIterations * 100)}% it`);
+  }
+  const used = spent.tokensIn + spent.tokensOut;
+  if (node.budget.maxTokens > 0 && used > 0) {
+    parts.push(`${Math.round(used / node.budget.maxTokens * 100)}% tok`);
+  }
+  return parts.length === 0 ? "" : ` \xB7 ${parts.join(", ")} of budget`;
+}
+function renderNode(node, lastAtDepth, lines) {
+  const mark = STATUS_MARK[node.status] ?? "?";
+  const { head: prefix, detail } = connectors(node.depth, lastAtDepth);
+  const head = [
+    `${prefix}${mark} ${node.label}`,
+    `[${node.status}]`,
+    node.role,
+    node.runtime ?? "no-runtime",
+    `budget ${budget(node)}`
+  ];
+  if (node.wallMs !== null) head.push(`wall ${ms(node.wallMs)}`);
+  lines.push(head.join("  "));
+  if (node.driver.records > 0 || node.role === "supervisor") {
+    lines.push(
+      `${detail}driver    ${node.driver.records} turn(s) \xB7 ${tokens2(node.driver)} \xB7 ${usd(node.driver)}` + budgetUse(node, node.driver)
+    );
+  }
+  if (node.children.records > 0 || node.role === "supervisor") {
+    lines.push(
+      `${detail}children  ${node.children.records} settled \xB7 ${tokens2(node.children)} \xB7 ${usd(node.children)}`
+    );
+  }
+  if (node.settled.records > 0) {
+    lines.push(
+      `${detail}settled   ${node.settled.iterations}it \xB7 ${tokens2(node.settled)} \xB7 ${usd(node.settled)}` + budgetUse(node, node.settled)
+    );
+  }
+  if (node.cancelReason !== null) lines.push(`${detail}cancelled: ${node.cancelReason}`);
+  if (node.outRef !== null) lines.push(`${detail}out ${node.outRef}`);
+}
+function renderQuestion(q, lines) {
+  const mark = q.blocking ? "BLOCKING" : q.urgency ?? "question";
+  lines.push(`  \u26A0 ${mark} from ${q.from ?? "unknown"}${q.status === null ? "" : ` [${q.status}]`}`);
+  for (const line of wrap(q.question, 4)) lines.push(line);
+  if (q.reason !== null) for (const line of wrap(`why: ${q.reason}`, 4)) lines.push(line);
+}
+function renderRunContextSnapshot(snapshot) {
+  const lines = [];
+  if (!snapshot.present) {
+    lines.push(`run ${snapshot.runDir}`);
+    lines.push("  no spawn-journal.jsonl yet \u2014 the run has not begun writing");
+    return lines.join("\n");
+  }
+  const totals = runTotals(snapshot);
+  lines.push(`run ${snapshot.runId ?? snapshot.runDir}`);
+  lines.push(
+    `  ${snapshot.nodes.length} node(s) \xB7 depth ${snapshot.maxDepth} \xB7 elapsed ${ms(elapsed(snapshot))}${snapshot.terminal ? "" : " \xB7 live"}`
+  );
+  lines.push(`  driver total    ${tokens2(totals.driver)} \xB7 ${usd(totals.driver)}`);
+  lines.push(`  worker total    ${tokens2(totals.workers)} \xB7 ${usd(totals.workers)}`);
+  lines.push("");
+  if (snapshot.nodes.length === 0) lines.push("  (no node spawned yet)");
+  forEachTreeNode(
+    snapshot.nodes,
+    (n) => n.parent,
+    (n) => n.id,
+    (node, lastAtDepth) => renderNode(node, lastAtDepth, lines)
+  );
+  if (snapshot.questions.length > 0) {
+    lines.push("");
+    for (const q of snapshot.questions) renderQuestion(q, lines);
+  }
+  if (snapshot.steers.length > 0) {
+    lines.push("");
+    for (const steer of snapshot.steers) {
+      lines.push(`  \u2192 steer ${steer.messageId ?? "(no id)"} to ${steer.toWorker ?? "(no target)"}`);
+      for (const line of wrap(steer.instruction, 4)) lines.push(line);
+    }
+  }
+  const problems = [];
+  if (snapshot.invalidJournalRows > 0) problems.push(`${snapshot.invalidJournalRows} unreadable journal row(s)`);
+  if (snapshot.invalidCoordinationRows > 0) {
+    problems.push(`${snapshot.invalidCoordinationRows} unreadable coordination row(s)`);
+  }
+  if (snapshot.treeError !== null) problems.push(snapshot.treeError);
+  if (snapshot.partialTail) problems.push("an artifact ends mid-line \u2014 the writer is still appending");
+  if (zeroPricedCost(totals.driver) || zeroPricedCost(totals.workers)) {
+    problems.push(
+      "spend recorded $0 with tokens spent: usdKnown was never set false, so this reads as FREE rather than unmetered. A harness-billed brain (a CLI on a subscription) looks exactly like this."
+    );
+  }
+  const unsettled = snapshot.nodes.filter(
+    (node) => node.status !== "done" && node.status !== "failed" && node.status !== "cancelled"
+  );
+  if (snapshot.terminal && unsettled.length > 0) {
+    problems.push(
+      `${unsettled.length} node(s) have no journaled settlement (${unsettled.map((n) => n.label).join(", ")}) \u2014 a driver reports its outcome through result.json, not the spawn journal`
+    );
+  }
+  if (problems.length > 0) {
+    lines.push("");
+    for (const problem of problems) lines.push(`  ! ${problem}`);
+  }
+  if (snapshot.result !== null) {
+    lines.push("");
+    lines.push(
+      `RESULT ${snapshot.result.kind ?? "unknown-kind"}${snapshot.result.reason === null ? "" : ` \xB7 ${snapshot.result.reason}`}`
+    );
+    if (snapshot.result.errorMessage !== null) {
+      lines.push(`  driver error (${snapshot.result.errorName ?? "Error"}):`);
+      for (const line of wrap(snapshot.result.errorMessage, 4)) lines.push(line);
+    }
+  }
+  return lines.join("\n");
+}
+function runTotals(snapshot) {
+  let driver = ZERO_ROLL;
+  let workers = ZERO_ROLL;
+  for (const node of snapshot.nodes) {
+    driver = mergeRolls(driver, node.driver);
+    if (node.role === "worker") workers = mergeRolls(workers, node.settled);
+  }
+  return { driver, workers };
+}
+function elapsed(snapshot) {
+  if (snapshot.begunAt === null) return null;
+  const end = snapshot.terminal ? snapshot.lastEventAt ?? Date.now() : Date.now();
+  return Math.max(0, end - snapshot.begunAt);
+}
+async function resolveRunContextDir(dir) {
+  if (await isFileRunContextDir(dir)) return dir;
+  const entries = await readdir16(dir, { withFileTypes: true }).catch(() => null);
+  if (entries === null) throw new Error(`cannot read ${dir}`);
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const child = join24(dir, entry.name);
+    if (await isFileRunContextDir(child)) candidates.push(child);
+  }
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length === 0) {
+    throw new Error(
+      `no spawn-journal.jsonl in ${dir} or any immediate subdirectory \u2014 point at a directory written by agent-runtime createFileRunContext()`
+    );
+  }
+  throw new Error(
+    `${candidates.length} run directories under ${dir}; name one:
+  ${candidates.join("\n  ")}`
+  );
+}
+
+// src/run-watch.ts
+import { stat as stat14 } from "fs/promises";
+async function resolveRunWatchTarget(target) {
+  const info = await stat14(target).catch(() => null);
+  if (info === null) throw new Error(`cannot read ${target}`);
+  if (info.isFile()) return { runDir: null, spanFiles: [target], requested: target };
+  const spanFiles = await findSpanSourceFiles(target);
+  if (await isFileRunContextDir(target)) return { runDir: target, spanFiles, requested: target };
+  const nested = await resolveRunContextDir(target).catch(() => null);
+  if (nested !== null) {
+    const nestedSpans = await findSpanSourceFiles(nested);
+    return {
+      runDir: nested,
+      spanFiles: [.../* @__PURE__ */ new Set([...spanFiles, ...nestedSpans])].sort(),
+      requested: target
+    };
+  }
+  if (spanFiles.length > 0) return { runDir: null, spanFiles, requested: target };
+  throw new Error(
+    `nothing to watch in ${target} \u2014 found neither spawn-journal.jsonl (agent-runtime createFileRunContext, at this level or one below) nor an OTLP span file (*.otlp.jsonl / *.spans.jsonl / *.traces.jsonl / *.openinference.jsonl)`
+  );
+}
+async function readRunWatchSnapshot(target) {
+  const journal = target.runDir === null ? null : await readRunContextSnapshot(target.runDir);
+  const spans = await Promise.all(target.spanFiles.map((file) => readSpanRunSnapshot(file)));
+  return {
+    target,
+    journal,
+    spans,
+    // A span file alone never declares itself finished — an emitter can always
+    // append one more span — so only the journal's `result.json` ends a watch.
+    terminal: journal !== null && journal.terminal
+  };
+}
+function sourceHeader(snapshot) {
+  const lines = ["sources"];
+  if (snapshot.journal !== null) {
+    lines.push(
+      `  journal  ${snapshot.target.runDir}/spawn-journal.jsonl  \u2192 authored budget, settled spend, settlement status (authoritative)`
+    );
+  }
+  for (const span2 of snapshot.spans) {
+    lines.push(
+      `  spans    ${span2.source}  \u2192 tree shape and per-turn detail${span2.readError === null ? "" : " (unreadable)"}`
+    );
+  }
+  if (snapshot.journal === null) {
+    lines.push("  (no spawn journal here: budget and settlement are UNAVAILABLE, not zero)");
+  }
+  if (snapshot.spans.length === 0) {
+    lines.push("  (no OTLP span file here: per-turn shape is UNAVAILABLE, not empty)");
+  }
+  return lines;
+}
+function renderRunWatchSnapshot(snapshot) {
+  const blocks = [sourceHeader(snapshot).join("\n")];
+  if (snapshot.journal !== null) blocks.push(renderRunContextSnapshot(snapshot.journal));
+  for (const span2 of snapshot.spans) blocks.push(renderSpanRunSnapshot(span2));
+  return blocks.join("\n\n");
+}
+async function watchRunTarget(target, opts = {}) {
+  const write = opts.write ?? ((text2) => process.stdout.write(text2));
+  const intervalMs = opts.intervalMs ?? 2e3;
+  let previous = "";
+  for (; ; ) {
+    const snapshot = await readRunWatchSnapshot(target);
+    const rendered = renderRunWatchSnapshot(snapshot);
+    if (opts.once) {
+      write(`${rendered}
+`);
+      return snapshot;
+    }
+    if (rendered !== previous) {
+      write(`
+${RULE}
+${(/* @__PURE__ */ new Date()).toISOString()}
+${rendered}
+`);
+      previous = rendered;
+    }
+    if (snapshot.terminal && opts.follow !== true) return snapshot;
+    if (aborted(opts.signal)) return snapshot;
+    await sleep2(intervalMs, opts.signal);
+    if (aborted(opts.signal)) return await readRunWatchSnapshot(target);
+  }
+}
+function aborted(signal) {
+  return signal !== void 0 && signal.aborted;
+}
+function sleep2(msDelay, signal) {
+  return new Promise((resolve7) => {
+    const timer = setTimeout(resolve7, msDelay);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve7();
+      },
+      { once: true }
+    );
+  });
+}
+
 // src/observer.ts
 function loopKey(loop) {
   return `${loop.sessionId}:${loop.toolName}:${loop.argHash}`;
@@ -11014,9 +12092,9 @@ async function collectSessionSelection(groups, options = {}) {
 }
 
 // src/session-index.ts
-import { mkdtemp as mkdtemp7, readdir as readdir15, readFile as readFile10, stat as stat13, writeFile as writeFile7 } from "fs/promises";
+import { mkdtemp as mkdtemp7, readdir as readdir17, readFile as readFile11, stat as stat15, writeFile as writeFile7 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { dirname as dirname7, join as join22 } from "path";
+import { dirname as dirname7, join as join25 } from "path";
 function indexRow(record2) {
   return {
     session: record2.session,
@@ -11071,7 +12149,7 @@ function buildSessionIndex(records, opts = {}) {
 }
 async function pathStat2(path) {
   try {
-    return await stat13(path);
+    return await stat15(path);
   } catch {
     return null;
   }
@@ -11089,7 +12167,7 @@ async function findContextRoot(cwd) {
   if (!s) return null;
   if (!s.isDirectory()) current = dirname7(current);
   for (; ; ) {
-    if (await pathStat2(join22(current, ".git")) || await dirExists(join22(current, ".evolve")) || await fileExists(join22(current, "AGENTS.md")) || await fileExists(join22(current, "CLAUDE.md"))) {
+    if (await pathStat2(join25(current, ".git")) || await dirExists(join25(current, ".evolve")) || await fileExists(join25(current, "AGENTS.md")) || await fileExists(join25(current, "CLAUDE.md"))) {
       return current;
     }
     const parent = dirname7(current);
@@ -11132,7 +12210,7 @@ async function summarizeFile(path, kind) {
   const base = { kind, path, bytes: Number(s.size), mtimeMs: Number(s.mtimeMs) };
   if (!path.endsWith(".md") && !path.endsWith(".jsonl")) return base;
   try {
-    const text2 = await readFile10(path, "utf8");
+    const text2 = await readFile11(path, "utf8");
     const lines = countLines(text2);
     const jsonl2 = path.endsWith(".jsonl") ? summarizeJsonl(text2) : void 0;
     return {
@@ -11151,13 +12229,13 @@ async function walkMarkdown(root, kind, maxFiles = 100) {
     if (out.length >= maxFiles) return;
     let entries;
     try {
-      entries = await readdir15(dir, { withFileTypes: true });
+      entries = await readdir17(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (out.length >= maxFiles) return;
-      const path = join22(dir, entry.name);
+      const path = join25(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(path);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -11172,20 +12250,20 @@ async function walkMarkdown(root, kind, maxFiles = 100) {
 async function collectContextRoot(root) {
   const files = [];
   for (const name of ["AGENTS.md", "CLAUDE.md", "GEMINI.md"]) {
-    const summary = await summarizeFile(join22(root, name), "instruction-doc");
+    const summary = await summarizeFile(join25(root, name), "instruction-doc");
     if (summary) files.push(summary);
   }
-  const evolve = join22(root, ".evolve");
+  const evolve = join25(root, ".evolve");
   for (const name of ["skill-runs.jsonl", "governor.jsonl", "experiments.jsonl"]) {
-    const summary = await summarizeFile(join22(evolve, name), "evolve-jsonl");
+    const summary = await summarizeFile(join25(evolve, name), "evolve-jsonl");
     if (summary) files.push(summary);
   }
   for (const name of ["scorecard.json"]) {
-    const summary = await summarizeFile(join22(evolve, name), "evolve-json");
+    const summary = await summarizeFile(join25(evolve, name), "evolve-json");
     if (summary) files.push(summary);
   }
-  files.push(...await walkMarkdown(join22(evolve, "reflections"), "reflection"));
-  files.push(...await walkMarkdown(join22(evolve, "handoffs"), "handoff"));
+  files.push(...await walkMarkdown(join25(evolve, "reflections"), "reflection"));
+  files.push(...await walkMarkdown(join25(evolve, "handoffs"), "handoff"));
   return { root, files: files.sort((a, b) => a.path.localeCompare(b.path)) };
 }
 async function collectContextIndex(records) {
@@ -11231,19 +12309,19 @@ function serializeSessionIndex(index) {
 `;
 }
 async function writeSessionIndexFile(index, outPath) {
-  const path = outPath ?? join22(await mkdtemp7(join22(tmpdir6(), "traces-index-")), "session-index.json");
+  const path = outPath ?? join25(await mkdtemp7(join25(tmpdir6(), "traces-index-")), "session-index.json");
   await writeFile7(path, serializeSessionIndex(index), "utf8");
   return path;
 }
 
 // src/upload-state.ts
-import { mkdir as mkdir5, readFile as readFile11, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile12, writeFile as writeFile8 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { dirname as dirname8, join as join23 } from "path";
+import { dirname as dirname8, join as join26 } from "path";
 import { contentHash } from "@tangle-network/agent-eval";
 function stateFile() {
-  const base = process.env.XDG_STATE_HOME ?? join23(homedir12(), ".local", "state");
-  return join23(base, "tangle-traces", "uploaded.json");
+  const base = process.env.XDG_STATE_HOME ?? join26(homedir12(), ".local", "state");
+  return join26(base, "tangle-traces", "uploaded.json");
 }
 function uploadKey(harness, sessionId) {
   return `${harness}:${sessionId}`;
@@ -11256,7 +12334,7 @@ function outboundHash(events, identity) {
 }
 async function loadState() {
   try {
-    return JSON.parse(await readFile11(stateFile(), "utf8"));
+    return JSON.parse(await readFile12(stateFile(), "utf8"));
   } catch {
     return {};
   }
@@ -11272,10 +12350,10 @@ function alreadyUploaded(state, harness, sessionId, hash2) {
 }
 
 // src/upload.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import { createRequire } from "module";
 import { hostname as hostname2 } from "os";
-import { basename as basename13, join as join24 } from "path";
+import { basename as basename14, join as join27 } from "path";
 import { hostedClientFromEnv } from "@tangle-network/agent-eval/hosted";
 import { REDACTION_VERSION } from "@tangle-network/agent-eval/traces";
 var require2 = createRequire(import.meta.url);
@@ -11299,7 +12377,7 @@ async function planUpload(opts = {}) {
 async function gitBranch(cwd) {
   if (!cwd) return void 0;
   try {
-    const head = await readFile12(join24(cwd, ".git", "HEAD"), "utf8");
+    const head = await readFile13(join27(cwd, ".git", "HEAD"), "utf8");
     const m = head.match(/^ref:\s*refs\/heads\/(.+)$/m);
     return m?.[1]?.trim();
   } catch {
@@ -11309,7 +12387,7 @@ async function gitBranch(cwd) {
 async function sessionMeta(item) {
   const meta = {
     [ATTR.HARNESS]: item.ref.harness,
-    [ATTR.SESSION_FILE]: basename13(item.ref.path),
+    [ATTR.SESSION_FILE]: basename14(item.ref.path),
     [ATTR.HOST]: hostname2(),
     [ATTR.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
     [ATTR.REDACTION_VERSION]: REDACTION_VERSION,
@@ -11582,6 +12660,43 @@ export {
   traceStreamEventsFromSpans,
   serializeTraceStreamEvent,
   streamSessions,
+  SPAWN_JOURNAL_FILE,
+  COORDINATION_LOG_FILE,
+  RESULT_FILE,
+  BLOBS_DIR,
+  readRunContextJournal,
+  inferRole,
+  readCoordinationLog,
+  readFileRunContext,
+  fileRunContextSupervisorRunReader,
+  isFileRunContextDir,
+  ZERO_ROLL,
+  addSpend,
+  mergeRolls,
+  readRunContextSnapshot,
+  RULE,
+  int,
+  ms,
+  usd,
+  zeroPricedCost,
+  tokens2 as tokens,
+  STATUS_MARK,
+  connectors,
+  forEachTreeNode,
+  wrap,
+  EMPTY_SPAN_RUN_SNAPSHOT,
+  buildSpanRunTree,
+  readSpanRunSnapshot,
+  spanRunTotals,
+  renderSpanRunSnapshot,
+  findSpanSourceFiles,
+  renderRunContextSnapshot,
+  runTotals,
+  resolveRunContextDir,
+  resolveRunWatchTarget,
+  readRunWatchSnapshot,
+  renderRunWatchSnapshot,
+  watchRunTarget,
   watchSessions,
   collectSessionWorkflow,
   collectSessionSelection,