@tangle-network/agent-eval 0.150.1 → 0.161.0

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

@@ -1,5 +1,5 @@
-import { b as RolloutSplit } from "../schema-Cef2cFmb.js";
-import { C as Unavailable, D as showMeasured, E as isUnavailable, O as unavailable, S as SupervisorRunTreeGapCode, T as WorkerLogSource, _ as SupervisorRunReport, a as OrchestrationMetrics, b as SupervisorRunTree, c as PerWorkerRow, d as SUPERVISOR_RUN_ROLLUP_SCHEMA, f as SUPERVISOR_RUN_SCHEMA, g as SupervisorRunReader, h as SupervisorRunNodeRole, i as NO_SOURCE_LIMITS, l as RoleSpend, m as SteerBreakdown, n as EconomicsMetrics, o as OutcomeMetrics, p as SourceLimits, r as Measured, s as PatchStats, t as DecisionMetrics, u as RollupCellRow, v as SupervisorRunRollup, w as WallDistribution, x as SupervisorRunTreeGap, y as SupervisorRunSources } from "../types-yLK8gXE9.js";
+import { A as unavailable, C as SupervisorRunTreeGap, D as WorkerLogSource, E as WallDistribution, O as isUnavailable, S as SupervisorRunTree, T as Unavailable, _ as SupervisorRunNodeRole, a as OrchestrationMetrics, b as SupervisorRunRollup, c as PerWorkerRow, d as SUPERVISOR_RUN_ROLLUP_SCHEMA, f as SUPERVISOR_RUN_SCHEMA, g as SteerBreakdown, h as SpendMeasurements, i as NO_SOURCE_LIMITS, k as showMeasured, l as RoleSpend, m as SpendMeasurement, n as EconomicsMetrics, o as OutcomeMetrics, p as SourceLimits, r as Measured, s as PatchStats, t as DecisionMetrics, u as RollupCellRow, v as SupervisorRunReader, w as SupervisorRunTreeGapCode, x as SupervisorRunSources, y as SupervisorRunReport } from "../types-DeIUdzNd.js";
+import { y as RolloutSplit } from "../schema-BzWDXhOR.js";
 //#region src/supervisor-run/source-facts.d.ts
 interface Tokens {
   input: number;
@@ -149,6 +149,13 @@ interface SupervisorTreeFacts {
   readonly state: Record<string, unknown> | null;
   readonly startedAt: number | null;
   readonly completedAt: number | null;
+  /**
+   * First and last stamped tree events (spawned / settled / cancelled /
+   * metered) in the journal — the bounds of observed activity. They derive a
+   * lower-bound wall for a store that writes no completion stamp.
+   */
+  readonly firstEventAt: number | null;
+  readonly lastEventAt: number | null;
 }
 /**
  * How a journal's rows were shaped on disk.
@@ -185,12 +192,6 @@ declare function parsePatch(text: string): PatchStats;
 declare function rollupSupervisorRuns(reports: readonly SupervisorRunReport[]): SupervisorRunRollup;
 //#endregion
 //#region src/supervisor-run/claude-code-reader.d.ts
-/** Tool names that spawn a child agent. `Task` is the older name for `Agent`. */
-declare const DEFAULT_SPAWN_TOOLS: readonly ['Agent', 'Task'];
-/** Tool names that deliver a message to an ALREADY-RUNNING child agent. */
-declare const DEFAULT_STEER_TOOLS: readonly ['SendMessage'];
-/** Tool names that stop a running child agent. */
-declare const DEFAULT_CANCEL_TOOLS: readonly ['TaskStop', 'KillAgent'];
 interface ClaudeCodeReaderOptions {
   /** The main session transcript: `~/.claude/projects/<slug>/<sessionId>.jsonl`. */
   readonly transcriptPath: string;
@@ -302,13 +303,6 @@ interface WriteSupervisorRunOptions extends LoopsReaderOptions {
  * every metric says why.
  */
 declare function writeSupervisorRunReport(runDir: string, opts?: WriteSupervisorRunOptions): Promise<SupervisorRunReport>;
-/**
- * File stem for out-of-tree reports. Built from the run path's identifying
- * segments — candidate tag (the segment under `arm-runs/`), rep, instance, arm
- * — so two runs of the same instance from different candidates/reps never
- * overwrite each other.
- */
-declare function supervisorReportStem(runDir: string): string;
 /**
  * Best-effort wrapper for a hot path: a reporting failure must never kill a run
  * that already produced real work. Returns null and logs the reason instead.
@@ -374,18 +368,33 @@ interface SupervisorRolloutOptions {
 declare function supervisorRunRolloutLines(src: SupervisorRunSources, opts?: SupervisorRolloutOptions): SupervisorRunTree;
 //#endregion
 //#region src/supervisor-run/runtime-reader.d.ts
+interface RuntimeReaderOptions {
+  /**
+   * Throw on a missing spawn journal instead of returning absent-shaped
+   * sources. The default (false) models a journal-less run dir — a
+   * pre-supervise death, a backfilled zombie — as a readable absence.
+   */
+  readonly strict?: boolean;
+}
 /**
  * Read one agent-runtime `createFileRunContext(dir)` directory.
  *
+ * A run dir without `spawn-journal.jsonl` returns the same absent-shaped
+ * sources `readLoopsSupervisorRun` returns for a missing store: `journal` and
+ * `workers` null, each with its reason, so every dependent metric reads
+ * `unavailable` — never 0 and never a throw. Pass `strict: true` to throw on
+ * the missing journal instead. A journal that exists but cannot be parsed
+ * always throws: a corrupt journal is a defect, not an absence.
+ *
  * The reader translates storage envelopes only. It does not assign research
  * roles, interpret artifacts, or turn process completion into a quality
  * verdict.
  */
-declare function readRuntimeSupervisorRun(runDir: string): Promise<SupervisorRunSources>;
+declare function readRuntimeSupervisorRun(runDir: string, opts?: RuntimeReaderOptions): Promise<SupervisorRunSources>;
 /** The agent-runtime file-backed layout as a `SupervisorRunReader`. */
-declare function runtimeSupervisorRunReader(runDir: string): SupervisorRunReader;
+declare function runtimeSupervisorRunReader(runDir: string, opts?: RuntimeReaderOptions): SupervisorRunReader;
 /** True when a directory contains Runtime's canonical file-backed journal. */
 declare function isRuntimeSupervisorRunDir(runDir: string): Promise<boolean>;
 //#endregion
-export { type ClaudeCodeReaderOptions, type CloseRow, DEFAULT_CANCEL_TOOLS, DEFAULT_SPAWN_TOOLS, DEFAULT_STEER_TOOLS, type DecisionMetrics, type EconomicsMetrics, type LoopsReaderOptions, type Measured, NO_SOURCE_LIMITS, type OrchestrationMetrics, type OutcomeMetrics, type PatchStats, type PerWorkerRow, type RoleSpend, type RollupCellRow, SUPERVISOR_RUN_INTEGRITY_SCHEMA, SUPERVISOR_RUN_ROLLUP_SCHEMA, SUPERVISOR_RUN_SCHEMA, type SourceLimits, type SpawnRow, type SteerAcknowledgementFact, type SteerBreakdown, type SteerRequestFact, type SupervisorJournalDialect, type SupervisorRolloutOptions, type SupervisorRunIntegrityEvidence, type SupervisorRunIntegrityIssue, type SupervisorRunIntegrityIssueCode, type SupervisorRunIntegrityOptions, type SupervisorRunIntegrityReport, type SupervisorRunIntegritySeverity, type SupervisorRunNodeRole, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunRollup, type SupervisorRunSourceOnlyCheckCode, type SupervisorRunSources, type SupervisorRunTree, type SupervisorRunTreeGap, type SupervisorRunTreeGapCode, type SupervisorTreeFacts, type Unavailable, type WallDistribution, type WorkerLogFacts, type WorkerLogSource, type WriteSupervisorRunOptions, analyzeSupervisorRun, analyzeSupervisorRunIntegrity, analyzeSupervisorRunSources, claudeCodeSupervisorRunReader, findSupervisorRunDirIn, findSupervisorRunDirs, isRuntimeSupervisorRunDir, isUnavailable, loopsSupervisorRunReader, parsePatch, parseSupervisorTree, readClaudeCodeSupervisorRun, readLoopsSupervisorRun, readRuntimeSupervisorRun, renderSupervisorRollupMarkdown, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, reportSupervisorRound, rollupSupervisorRuns, runtimeSupervisorRunReader, showMeasured, supervisorReportStem, supervisorRunRolloutLines, unavailable, writeSupervisorRunReport, writeSupervisorRunReportSafe };
+export { type ClaudeCodeReaderOptions, type CloseRow, type DecisionMetrics, type EconomicsMetrics, type LoopsReaderOptions, type Measured, NO_SOURCE_LIMITS, type OrchestrationMetrics, type OutcomeMetrics, type PatchStats, type PerWorkerRow, type RoleSpend, type RollupCellRow, type RuntimeReaderOptions, SUPERVISOR_RUN_INTEGRITY_SCHEMA, SUPERVISOR_RUN_ROLLUP_SCHEMA, SUPERVISOR_RUN_SCHEMA, type SourceLimits, type SpawnRow, type SpendMeasurement, type SpendMeasurements, type SteerAcknowledgementFact, type SteerBreakdown, type SteerRequestFact, type SupervisorJournalDialect, type SupervisorRolloutOptions, type SupervisorRunIntegrityEvidence, type SupervisorRunIntegrityIssue, type SupervisorRunIntegrityIssueCode, type SupervisorRunIntegrityOptions, type SupervisorRunIntegrityReport, type SupervisorRunIntegritySeverity, type SupervisorRunNodeRole, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunRollup, type SupervisorRunSourceOnlyCheckCode, type SupervisorRunSources, type SupervisorRunTree, type SupervisorRunTreeGap, type SupervisorRunTreeGapCode, type SupervisorTreeFacts, type Unavailable, type WallDistribution, type WorkerLogFacts, type WorkerLogSource, type WriteSupervisorRunOptions, analyzeSupervisorRun, analyzeSupervisorRunIntegrity, analyzeSupervisorRunSources, claudeCodeSupervisorRunReader, findSupervisorRunDirIn, findSupervisorRunDirs, isRuntimeSupervisorRunDir, isUnavailable, loopsSupervisorRunReader, parsePatch, parseSupervisorTree, readClaudeCodeSupervisorRun, readLoopsSupervisorRun, readRuntimeSupervisorRun, renderSupervisorRollupMarkdown, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, reportSupervisorRound, rollupSupervisorRuns, runtimeSupervisorRunReader, showMeasured, supervisorRunRolloutLines, unavailable, writeSupervisorRunReport, writeSupervisorRunReportSafe };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/supervisor-run/source-facts.ts","../../src/supervisor-run/analyze.ts","../../src/supervisor-run/claude-code-reader.ts","../../src/supervisor-run/integrity-types.ts","../../src/supervisor-run/integrity.ts","../../src/supervisor-run/loops-reader.ts","../../src/supervisor-run/render.ts","../../src/supervisor-run/rollout-nodes.ts","../../src/supervisor-run/runtime-reader.ts"],"mappings":";;;UAwBU;EACR;EACA;EACA;EACA;;EAEA;;UAGQ;EACR,QAAQ;EACR;;UAgFe;;EAEf;EACA;EACA;EACA;;EAEA,MAAM;;EAEN;;EAEA;EACA;;EAEA;EACA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,OAAO;;EAEP;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA,eAAe;EACf,uBAAuB;;UAGR;;EAEf;EACA;;UAGe;;EAEf;;EAEA;EACA;;;;;;UAOe;WACN;WACA,iBAAiB;WACjB,iBAAiB;WACjB,uBAAuB;WACvB,uBAAuB;WACvB;IACP;IACA;IACA;IACA;;IAEA;IACA;;IAEA;;WAEO,YAAY,oBAAoB;;WAEhC,wBAAwB;;WAExB;;;;;;;;;WASA;;WAEA;;;;;;WAMA,0BAA0B,SAAS;;;;;;;WAOnC;;WAEA,gBAAgB;;WAEhB,OAAO;WACP;WACA;;;;;;;;;;;;;;;;;;KAmDC;iBAiFI,oBAAoB,KAAK,uBAAuB;;;;;;;iBCvUhD,4BACd,KAAK,sBACL,qBACC;;iBAwqBa,WAAW,eAAe;;;;;;iBA+C1B,qBAAqB,kBAAkB,wBAAwB;;;;cCjtBlE;;cAEA;;cAEA;UASI;;WAEN;;;;;WAKA;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;iBAmOW,4BACpB,MAAM,0BACL,QAAQ;;iBAiUK,8BAA8B,MAAM,0BAA0B;;;cCnoBjE;KAED;KAEA;KAKA;UAmCK;WACN;WACA;;UAGM;WACN,MAAM;WACN;WACA,UAAU;WACV;WACA;WACA;WACA,mBAAmB;WACnB;WACA,WAAW,SAAS;;UAGd;WACN,eAAe;WACf;WACA;WACA,MAAM;WACN,iBAAiB;;UAGX;;WAEN;;;;;;;;iBC5BK,8BACd,OAAO,uBAAuB,mBAC9B,UAAS,gCACR;;;;;;;iBCDmB,uBAAuB,aAAa;UAUzC;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;;iBAQW,uBACpB,gBACA,OAAM,qBACL,QAAQ;;iBAmKK,yBACd,gBACA,OAAM,qBACL;;;;;;iBAkCmB,qBACpB,gBAAgB,sBAAsB,sBACtC,OAAM,qBACL,QAAQ;UAgBM,kCAAkC;;WAExC;;WAEA;;;;;;WAMA;;;;;;;;iBASW,yBACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;;iBAyBK,qBAAqB;;;;;iBAiBf,6BACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;iBAgBW,sBACpB,gBACA,OAAM;EAA8B;IACnC,QAAQ;;;;;;;iBA+BW,sBAAsB,eAAe;;;;;;;iBCzY3C,4BAA4B,GAAG;iBAgC/B,4BAA4B,GAAG;iBAyK/B,+BACd,QAAQ,qBACR;;;UCvLe;;WAEN;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;iBAwBK,0BACd,KAAK,sBACL,OAAM,2BACL;;;;;;;;;;iBC4UmB,yBAAyB,iBAAiB,QAAQ;;iBA8DxD,2BAA2B,iBAAiB;;iBAKtC,0BAA0B,iBAAiB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/supervisor-run/source-facts.ts","../../src/supervisor-run/analyze.ts","../../src/supervisor-run/claude-code-reader.ts","../../src/supervisor-run/integrity-types.ts","../../src/supervisor-run/integrity.ts","../../src/supervisor-run/loops-reader.ts","../../src/supervisor-run/render.ts","../../src/supervisor-run/rollout-nodes.ts","../../src/supervisor-run/runtime-reader.ts"],"mappings":";;;UAwBU;EACR;EACA;EACA;EACA;;EAEA;;UAGQ;EACR,QAAQ;EACR;;UAgFe;;EAEf;EACA;EACA;EACA;;EAEA,MAAM;;EAEN;;EAEA;EACA;;EAEA;EACA;;UAGe;EACf;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA,OAAO;;EAEP;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA,eAAe;EACf,uBAAuB;;UAGR;;EAEf;EACA;;UAGe;;EAEf;;EAEA;EACA;;;;;;UAOe;WACN;WACA,iBAAiB;WACjB,iBAAiB;WACjB,uBAAuB;WACvB,uBAAuB;WACvB;IACP;IACA;IACA;IACA;;IAEA;IACA;;IAEA;;WAEO,YAAY,oBAAoB;;WAEhC,wBAAwB;;WAExB;;;;;;;;;WASA;;WAEA;;;;;;WAMA,0BAA0B,SAAS;;;;;;;WAOnC;;WAEA,gBAAgB;;WAEhB,OAAO;WACP;WACA;;;;;;WAMA;WACA;;;;;;;;;;;;;;;;;;KAmDC;iBAiFI,oBAAoB,KAAK,uBAAuB;;;;;;;iBC5UhD,4BACd,KAAK,sBACL,qBACC;;iBAktBa,WAAW,eAAe;;;;;;iBA+C1B,qBAAqB,kBAAkB,wBAAwB;;;UChvB9D;;WAEN;;;;;WAKA;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;iBAmOW,4BACpB,MAAM,0BACL,QAAQ;;iBAiUK,8BAA8B,MAAM,0BAA0B;;;cCnoBjE;KAED;KAEA;KAKA;UAmCK;WACN;WACA;;UAGM;WACN,MAAM;WACN;WACA,UAAU;WACV;WACA;WACA;WACA,mBAAmB;WACnB;WACA,WAAW,SAAS;;UAGd;WACN,eAAe;WACf;WACA;WACA,MAAM;WACN,iBAAiB;;UAGX;;WAEN;;;;;;;;iBC5BK,8BACd,OAAO,uBAAuB,mBAC9B,UAAS,gCACR;;;;;;;iBCDmB,uBAAuB,aAAa;UAUzC;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;;iBAQW,uBACpB,gBACA,OAAM,qBACL,QAAQ;;iBAmKK,yBACd,gBACA,OAAM,qBACL;;;;;;iBAkCmB,qBACpB,gBAAgB,sBAAsB,sBACtC,OAAM,qBACL,QAAQ;UAgBM,kCAAkC;;WAExC;;WAEA;;;;;;WAMA;;;;;;;;iBASW,yBACpB,gBACA,OAAM,4BACL,QAAQ;;;;;iBA0CW,6BACpB,gBACA,OAAM,4BACL,QAAQ;;;;;;iBAgBW,sBACpB,gBACA,OAAM;EAA8B;IACnC,QAAQ;;;;;;;iBA+BW,sBAAsB,eAAe;;;;;;;iBCzY3C,4BAA4B,GAAG;iBAiC/B,4BAA4B,GAAG;iBA+K/B,+BACd,QAAQ,qBACR;;;UC9Le;;WAEN;;WAEA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;;WAEA;;;;;;;iBAwBK,0BACd,KAAK,sBACL,OAAM,2BACL;;;UCsUc;;;;;;WAMN;;;;;;;;;;;;;;;;iBAsDW,yBACpB,gBACA,OAAM,uBACL,QAAQ;;iBAkEK,2BACd,gBACA,OAAM,uBACL;;iBAKmB,0BAA0B,iBAAiB"}

package/dist/supervisor-run/index.js

@@ -1,5 +1,6 @@
-import { d as transcriptFromEntries, i as openOpencodeDb, l as parseClaudeEntries, r as findOpencodeSessionsByDirectory, t as DEFAULT_OPENCODE_DB } from "../opencode-sqlite-DJWAXLms.js";
-import { a as parseJsonl, c as SUPERVISOR_RUN_INTEGRITY_SCHEMA, i as parseJson, n as supervisorRunRolloutLines, o as parseSupervisorTree, r as asRecord, s as workerSourceKey, t as analyzeSupervisorRunIntegrity } from "../integrity-DysDBWDu.js";
+import { o as summarizeNumberSeries } from "../descriptive-jDOuI6mz.js";
+import { c as parseClaudeEntries, n as findOpencodeSessionsByDirectory, r as openOpencodeDb, t as DEFAULT_OPENCODE_DB, u as transcriptFromEntries } from "../opencode-sqlite-eK6HW6dr.js";
+import { a as parseJsonl, c as SUPERVISOR_RUN_INTEGRITY_SCHEMA, i as parseJson, n as supervisorRunRolloutLines, o as parseSupervisorTree, r as asRecord, s as workerSourceKey, t as analyzeSupervisorRunIntegrity } from "../integrity-CyWSSoQS.js";
 import { basename, dirname, join } from "node:path";
 import { appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 //#region src/supervisor-run/types.ts
@@ -44,7 +45,7 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 		gaps.push(`${what}: ${reason}`);
 		return unavailable(reason);
 	};
-	const journalMissing = src.supRunDir === null ? "no supervisor run dir under <ws>/.agent/supervisor (or legacy <ws>/.loops/supervisor)" : "journal.jsonl absent";
+	const journalMissing = src.journalMissingReason ?? (src.supRunDir === null ? "no supervisor run dir under <ws>/.agent/supervisor (or legacy <ws>/.loops/supervisor)" : "journal.jsonl absent");
 	const haveJournal = src.journal !== null;
 	const tree = parseSupervisorTree(src);
 	const state = tree.state;
@@ -68,7 +69,22 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 		const matches = spawnsForSource(worker);
 		return matches.length === 1 ? matches[0] ?? null : null;
 	};
-	const supervisorWallMs = startedAt !== null && completedAt !== null && completedAt >= startedAt ? completedAt - startedAt : !haveJournal ? gap("supervisorWallMs", journalMissing) : gap("supervisorWallMs", "no parseable start/complete timestamps in state.json or journal");
+	const wallSpanStart = startedAt ?? tree.firstEventAt;
+	const wallSpanEnd = tree.lastEventAt;
+	let supervisorWallMs;
+	let supervisorWallSource;
+	if (startedAt !== null && completedAt !== null && completedAt >= startedAt) {
+		supervisorWallMs = completedAt - startedAt;
+		supervisorWallSource = "stamps";
+	} else if (completedAt === null && wallSpanStart !== null && wallSpanEnd !== null && wallSpanEnd >= wallSpanStart) {
+		supervisorWallMs = wallSpanEnd - wallSpanStart;
+		supervisorWallSource = "journal-span";
+	} else {
+		const reason = !haveJournal ? journalMissing : "no parseable start/complete timestamps in state.json or journal";
+		supervisorWallMs = gap("supervisorWallMs", reason);
+		supervisorWallSource = unavailable(reason);
+	}
+	const wallEndAt = completedAt ?? (supervisorWallSource === "journal-span" ? wallSpanEnd : null);
 	const steerRows = [];
 	let steerQueuedTotal = 0;
 	let steerDeliveredTotal = 0;
@@ -135,8 +151,8 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 		if (live > maxConcurrency) maxConcurrency = live;
 		prev = step.at;
 	}
-	if (prev !== null && completedAt !== null && completedAt >= prev) {
-		const span = completedAt - prev;
+	if (prev !== null && wallEndAt !== null && wallEndAt >= prev) {
+		const span = wallEndAt - prev;
 		if (live === 0) idleMs += span;
 		sumWorkerWallMs += span * live;
 	}
@@ -203,6 +219,7 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 		delegationDepth: haveJournal ? delegationDepth : unavailable(journalMissing),
 		timeToFirstSpawnMs: startedAt !== null && firstWorkerSpawnAt !== null ? firstWorkerSpawnAt - startedAt : haveJournal ? unavailable("no worker spawn timestamps") : unavailable(journalMissing),
 		supervisorWallMs,
+		supervisorWallSource,
 		idleMs: isUnavailable(supervisorWallMs) ? unavailable(supervisorWallMs.unavailable) : idleMs,
 		idlePct: isUnavailable(supervisorWallMs) || supervisorWallMs === 0 ? isUnavailable(supervisorWallMs) ? unavailable(supervisorWallMs.unavailable) : unavailable("supervisor wall is 0ms") : round(idleMs / supervisorWallMs * 100, 1),
 		workerUtilization: isUnavailable(supervisorWallMs) || supervisorWallMs === 0 ? isUnavailable(supervisorWallMs) ? unavailable(supervisorWallMs.unavailable) : unavailable("supervisor wall is 0ms") : round(sumWorkerWallMs / supervisorWallMs, 3)
@@ -267,8 +284,24 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 	const workerOut = workerTokenLimit !== null ? unavailable(workerTokenLimit) : sq !== null ? journalWorkerOut + sq.output : haveJournal ? journalWorkerOut : unavailable(harnessGapReason);
 	const stateResult = asRecord(state?.result);
 	const stateUsd = typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : null;
+	const resultSpentTotal = asRecord(result?.spentTotal);
+	const resultCloseUsd = typeof resultSpentTotal.usd === "number" && Number.isFinite(resultSpentTotal.usd) ? resultSpentTotal.usd : null;
+	const closeUsd = stateUsd ?? resultCloseUsd;
 	const usdLimit = src.limits.spendUsd;
 	const totalUsd = usdLimit !== null ? gap("totalUsd", usdLimit) : stateUsd !== null ? round(stateUsd, 6) : haveJournal ? round(tree.brain.usd + journalWorkerUsd, 6) : gap("totalUsd", journalMissing);
+	const journalSpendRecords = tree.brain.meteredCount + rootChildCloses.filter((close) => close.hasSpend).length;
+	const journalDerivedAvailable = usdLimit === null && haveJournal;
+	const closeRecordAvailable = usdLimit === null && closeUsd !== null;
+	const spend = {
+		journalDerived: {
+			usd: journalDerivedAvailable ? round(tree.brain.usd + journalWorkerUsd, 6) : unavailable(usdLimit ?? journalMissing),
+			records: journalDerivedAvailable ? journalSpendRecords : 0
+		},
+		closeRecord: {
+			usd: closeRecordAvailable ? round(closeUsd, 6) : unavailable(usdLimit ?? "no close record: neither state.json result.spentUsd nor result.json spentTotal.usd is present"),
+			records: closeRecordAvailable ? 1 : 0
+		}
+	};
 	const perWorker = (src.workers ?? []).map((w) => {
 		const f = tree.workerLogs.get(workerSourceKey(w));
 		const matchingSpawns = spawnsForSource(w);
@@ -297,7 +330,7 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 			score: close?.score ?? f?.score ?? null
 		};
 	});
-	const walls = perWorker.map((w) => w.wallMs).filter((w) => w !== null).sort((a, b) => a - b);
+	const wallDistribution = summarizeNumberSeries(perWorker.map((w) => w.wallMs).filter((w) => w !== null));
 	const brainCalls = parseJsonl(src.brainLog);
 	const managerTokenLimit = src.limits.managerTokens;
 	const economics = {
@@ -318,17 +351,11 @@ function analyzeSupervisorRunSources(src, now = Date.now) {
 			usd: usdLimit !== null ? unavailable(usdLimit) : haveJournal ? round(journalWorkerUsd, 6) : unavailable(journalMissing),
 			source: workerTokenLimit !== null ? workerTokenLimit : sq !== null ? `journal settled spend + ${sq.store} sessions (n=${sq.sessions})` : `journal settled spend only — ${src.harnessMissingReason ?? "harness session store unavailable"}`
 		},
+		spend,
 		totalUsd,
 		totalUsdSource: usdLimit !== null ? usdLimit : stateUsd !== null ? `state.json result.spentUsd${rootChildCloses.length > 0 && journalWorkerUsd === 0 ? " — brain-priced only; worker CLI inference is unpriced (see worker token counts)" : ""}` : haveJournal ? "journal metered + settled usd" : journalMissing,
 		costPerAcceptedPatchUsd: isUnavailable(totalUsd) ? unavailable(totalUsd.unavailable) : isUnavailable(decision.accepted) ? unavailable(decision.accepted.unavailable) : decision.accepted === 0 ? unavailable("no accepted worker patch (cost has no denominator)") : round(totalUsd / decision.accepted, 6),
-		workerWallMsDistribution: walls.length === 0 ? unavailable(src.workers === null ? workersGapReason : "no worker start/finish pairs captured") : {
-			n: walls.length,
-			min: walls[0],
-			p50: quantile(walls, .5),
-			p90: quantile(walls, .9),
-			max: walls[walls.length - 1],
-			sum: walls.reduce((a, b) => a + b, 0)
-		},
+		workerWallMsDistribution: wallDistribution === null ? unavailable(src.workers === null ? workersGapReason : "no worker start/finish pairs captured") : wallDistribution,
 		perWorker: src.workers === null ? unavailable(workersGapReason) : perWorker
 	};
 	const patchStats = src.patch === null ? gap("patch", src.limits.deliverables ?? "delivered patch file absent") : parsePatch(src.patch);
@@ -386,10 +413,6 @@ function round(v, digits) {
 	const f = 10 ** digits;
 	return Math.round(v * f) / f;
 }
-function quantile(sorted, q) {
-	if (sorted.length === 0) return 0;
-	return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(q * sorted.length) - 1))];
-}
 /** Unified-diff stats. Counts `+++ b/<path>` targets, body +/- lines, and test-file touches. */
 function parsePatch(text) {
 	const files = /* @__PURE__ */ new Set();
@@ -435,6 +458,8 @@ function rollupSupervisorRuns(reports) {
 	const spawnVals = known(reports.map((r) => r.orchestration.workersSpawned));
 	const acceptVals = known(reports.map((r) => r.decision.accepted));
 	const usdVals = known(reports.map((r) => r.economics.totalUsd));
+	const journalSpendVals = known(reports.map((r) => r.economics.spend.journalDerived.usd));
+	const closeSpendVals = known(reports.map((r) => r.economics.spend.closeRecord.usd));
 	const resolvedVals = known(reports.map((r) => r.outcome.judgeResolved));
 	const sum = (xs) => xs.reduce((a, b) => a + b, 0);
 	const mean = (xs) => xs.length === 0 ? unavailable("no cell reported this metric") : round(sum(xs) / xs.length, 3);
@@ -461,6 +486,16 @@ function rollupSupervisorRuns(reports) {
 		workersSpawnedTotal: spawnVals.length === 0 ? unavailable("no cell reported spawns") : sum(spawnVals),
 		acceptedTotal: acceptVals.length === 0 ? unavailable("no cell reported acceptance") : sum(acceptVals),
 		usdTotal: usdVals.length === 0 ? unavailable("no cell reported spend") : round(sum(usdVals), 6),
+		spendUsd: {
+			journalDerived: {
+				value: journalSpendVals.length === 0 ? unavailable("no cell measured journal-derived spend") : round(sum(journalSpendVals), 6),
+				runs: journalSpendVals.length
+			},
+			closeRecord: {
+				value: closeSpendVals.length === 0 ? unavailable("no cell carried a close record") : round(sum(closeSpendVals), 6),
+				runs: closeSpendVals.length
+			}
+		},
 		resolvedCount: resolvedVals.length === 0 ? unavailable("no cell reported a judge verdict") : resolvedVals.filter((v) => v === true).length,
 		perCell
 	};
@@ -961,7 +996,7 @@ function renderSupervisorRunHeadline(r) {
 		`RUN-REPORT ${r.instanceId ?? "?"} [${r.arm ?? "?"}]`,
 		`  steers=${steerNote}`,
 		`  waves=${showMeasured(o.waves)} sizes=${isUnavailable(o.waveSizes) ? `unavailable — ${o.waveSizes.unavailable}` : `[${o.waveSizes.join(",")}]`} workers=${showMeasured(o.workersSpawned)} settled=${showMeasured(o.workersSettled)} cancelled=${showMeasured(o.workersCancelled)}`,
-		`  concurrency max=${showMeasured(o.maxConcurrency)} utilization=${showMeasured(o.workerUtilization)} idle=${fmtMs(o.idleMs)} (${showMeasured(o.idlePct)}%) wall=${fmtMs(o.supervisorWallMs)}`,
+		`  concurrency max=${showMeasured(o.maxConcurrency)} utilization=${showMeasured(o.workerUtilization)} idle=${fmtMs(o.idleMs)} (${showMeasured(o.idlePct)}%) wall=${fmtMs(o.supervisorWallMs)}${o.supervisorWallSource === "journal-span" ? " (journal-span lower bound)" : ""}`,
 		`  respawns=${showMeasured(o.respawns)} evidence→respawn=${showMeasured(r.decision.observeThenRespawn)} blind-respawn=${showMeasured(r.decision.respawnWithoutEvidence)} depth=${showMeasured(o.delegationDepth)}`,
 		`  accepted=${showMeasured(r.decision.accepted)} rejected=${showMeasured(r.decision.rejected)} empty-pass=${showMeasured(r.decision.emptyPass)}`,
 		`  brain=$${showMeasured(r.economics.brain.usd)} total=$${showMeasured(r.economics.totalUsd)} judge.resolved=${showMeasured(r.outcome.judgeResolved)} score=${showMeasured(r.outcome.judgeScore)} verify=${showMeasured(r.outcome.verifyPass)}`,
@@ -1008,7 +1043,7 @@ function renderSupervisorRunMarkdown(r) {
 	out.push(`| Repeated labels | ${isUnavailable(o.repeatedLabels) ? showMeasured(o.repeatedLabels) : o.repeatedLabels.length === 0 ? "none" : o.repeatedLabels.join(", ")} |`);
 	out.push(`| Delegation depth | ${showMeasured(o.delegationDepth)} |`);
 	out.push(`| Time to first spawn | ${fmtMs(o.timeToFirstSpawnMs)} |`);
-	out.push(`| Supervisor wall | ${fmtMs(o.supervisorWallMs)} |`);
+	out.push(`| Supervisor wall | ${fmtMs(o.supervisorWallMs)}${isUnavailable(o.supervisorWallSource) ? "" : ` (source: ${o.supervisorWallSource}${o.supervisorWallSource === "journal-span" ? ", lower bound" : ""})`} |`);
 	out.push(`| Idle (zero live workers) | ${fmtMs(o.idleMs)} (${showMeasured(o.idlePct)}%) |`);
 	out.push(`| Worker utilization (Σ worker wall ÷ supervisor wall) | ${showMeasured(o.workerUtilization)} |`);
 	out.push("");
@@ -1044,6 +1079,7 @@ function renderSupervisorRunMarkdown(r) {
 	if (!isUnavailable(e.brainTruncations) && e.brainTruncations > 0) out.push(`- **BRAIN OUTPUT TRUNCATED: ${e.brainTruncations} completion(s) hit \`finish_reason: "length"\`** — the supervisor acted on a half-written plan. Its output ceiling is too low; see \`brain.jsonl\` for the per-call \`req_max_tokens\`.`);
 	else out.push(`- Brain completions truncated (finish_reason=length): ${showMeasured(e.brainTruncations)}`);
 	out.push(`- Total USD: ${showMeasured(e.totalUsd)} (source: ${e.totalUsdSource})`);
+	out.push(`- Spend measured two ways: journal-derived $${showMeasured(e.spend.journalDerived.usd)} over ${e.spend.journalDerived.records} journal record(s) (execution accounting) · close-record $${showMeasured(e.spend.closeRecord.usd)} over ${e.spend.closeRecord.records} close record(s) (billing-shaped). Divergence is a signal, not an error.`);
 	out.push(`- Cost per accepted patch: ${showMeasured(e.costPerAcceptedPatchUsd)}`);
 	if (isUnavailable(e.workerWallMsDistribution)) out.push(`- Worker wall distribution: unavailable — ${e.workerWallMsDistribution.unavailable}`);
 	else {
@@ -1101,6 +1137,7 @@ function renderSupervisorRollupMarkdown(rollup, title = "Round rollup") {
 	out.push(`- Idle share (mean): ${showMeasured(rollup.idlePctMean)}%`);
 	out.push(`- Workers spawned: ${showMeasured(rollup.workersSpawnedTotal)} · accepted: ${showMeasured(rollup.acceptedTotal)}`);
 	out.push(`- Spend: $${showMeasured(rollup.usdTotal)} · judged resolved: ${showMeasured(rollup.resolvedCount)}/${rollup.cells}`);
+	out.push(`- Spend measured two ways: journal-derived $${showMeasured(rollup.spendUsd.journalDerived.value)} over ${rollup.spendUsd.journalDerived.runs}/${rollup.cells} runs (execution accounting) · close-record $${showMeasured(rollup.spendUsd.closeRecord.value)} over ${rollup.spendUsd.closeRecord.runs}/${rollup.cells} runs (billing-shaped)`);
 	out.push("");
 	out.push("| Instance | Arm | Steers | Waves | Utilization | Idle % | Resolved | USD |");
 	out.push("|---|---|---:|---:|---:|---:|---|---:|");
@@ -1330,15 +1367,56 @@ function runtimeState(root, startedAt, result, trajectory, resultPath, trajector
 	});
 }
 /**
+* Sources for a run dir whose spawn journal does not exist. Mirrors the
+* absent shape `readLoopsSupervisorRun` returns for a missing store: every
+* journal-dependent metric downstream reads `unavailable`, never 0.
+*/
+function absentRuntimeSupervisorRun(runDir, resultText) {
+	const reason = `no Runtime spawn journal (${JOURNAL_FILE}) under ${runDir}`;
+	return {
+		runRef: runDir,
+		instanceId: null,
+		arm: null,
+		supRunDir: null,
+		journal: null,
+		journalMissingReason: reason,
+		brainLog: null,
+		brainLogMissingReason: "Runtime FileRunContext records spend but not model completion finish reasons",
+		state: null,
+		progress: null,
+		workers: null,
+		workersMissingReason: reason,
+		result: resultText,
+		judge: null,
+		judgeSource: null,
+		patch: null,
+		driverLog: null,
+		harnessWorkerTokens: null,
+		harnessMissingReason: "Runtime FileRunContext has no external worker-token join",
+		limits: NO_SOURCE_LIMITS,
+		rootTranscriptRef: null,
+		traceCommand: "unavailable — Runtime FileRunContext records no provider-session trace identity"
+	};
+}
+/**
 * Read one agent-runtime `createFileRunContext(dir)` directory.
 *
+* A run dir without `spawn-journal.jsonl` returns the same absent-shaped
+* sources `readLoopsSupervisorRun` returns for a missing store: `journal` and
+* `workers` null, each with its reason, so every dependent metric reads
+* `unavailable` — never 0 and never a throw. Pass `strict: true` to throw on
+* the missing journal instead. A journal that exists but cannot be parsed
+* always throws: a corrupt journal is a defect, not an absence.
+*
 * The reader translates storage envelopes only. It does not assign research
 * roles, interpret artifacts, or turn process completion into a quality
 * verdict.
 */
-async function readRuntimeSupervisorRun(runDir) {
+async function readRuntimeSupervisorRun(runDir, opts = {}) {
 	const journalPath = join(runDir, JOURNAL_FILE);
-	const normalized = parseEnvelopeJournal(await readFile(journalPath, "utf8"), journalPath);
+	const rawJournal = opts.strict === true ? await readFile(journalPath, "utf8") : await readMaybe$1(journalPath);
+	if (rawJournal === null) return absentRuntimeSupervisorRun(runDir, await readMaybe$1(join(runDir, RESULT_FILE)));
+	const normalized = parseEnvelopeJournal(rawJournal, journalPath);
 	const resultText = await readMaybe$1(join(runDir, RESULT_FILE));
 	const trajectoryText = await readMaybe$1(join(runDir, TRAJECTORY_FILE));
 	const result = parseOptionalRecord(resultText, join(runDir, RESULT_FILE));
@@ -1381,10 +1459,10 @@ async function readRuntimeSupervisorRun(runDir) {
 	};
 }
 /** The agent-runtime file-backed layout as a `SupervisorRunReader`. */
-function runtimeSupervisorRunReader(runDir) {
+function runtimeSupervisorRunReader(runDir, opts = {}) {
 	return {
 		runRef: runDir,
-		read: () => readRuntimeSupervisorRun(runDir)
+		read: () => readRuntimeSupervisorRun(runDir, opts)
 	};
 }
 /** True when a directory contains Runtime's canonical file-backed journal. */
@@ -1685,6 +1763,6 @@ async function findSupervisorRunDirs(root) {
 	return found.sort();
 }
 //#endregion
-export { DEFAULT_CANCEL_TOOLS, DEFAULT_SPAWN_TOOLS, DEFAULT_STEER_TOOLS, NO_SOURCE_LIMITS, SUPERVISOR_RUN_INTEGRITY_SCHEMA, SUPERVISOR_RUN_ROLLUP_SCHEMA, SUPERVISOR_RUN_SCHEMA, analyzeSupervisorRun, analyzeSupervisorRunIntegrity, analyzeSupervisorRunSources, claudeCodeSupervisorRunReader, findSupervisorRunDirIn, findSupervisorRunDirs, isRuntimeSupervisorRunDir, isUnavailable, loopsSupervisorRunReader, parsePatch, parseSupervisorTree, readClaudeCodeSupervisorRun, readLoopsSupervisorRun, readRuntimeSupervisorRun, renderSupervisorRollupMarkdown, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, reportSupervisorRound, rollupSupervisorRuns, runtimeSupervisorRunReader, showMeasured, supervisorReportStem, supervisorRunRolloutLines, unavailable, writeSupervisorRunReport, writeSupervisorRunReportSafe };
+export { NO_SOURCE_LIMITS, SUPERVISOR_RUN_INTEGRITY_SCHEMA, SUPERVISOR_RUN_ROLLUP_SCHEMA, SUPERVISOR_RUN_SCHEMA, analyzeSupervisorRun, analyzeSupervisorRunIntegrity, analyzeSupervisorRunSources, claudeCodeSupervisorRunReader, findSupervisorRunDirIn, findSupervisorRunDirs, isRuntimeSupervisorRunDir, isUnavailable, loopsSupervisorRunReader, parsePatch, parseSupervisorTree, readClaudeCodeSupervisorRun, readLoopsSupervisorRun, readRuntimeSupervisorRun, renderSupervisorRollupMarkdown, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, reportSupervisorRound, rollupSupervisorRuns, runtimeSupervisorRunReader, showMeasured, supervisorRunRolloutLines, unavailable, writeSupervisorRunReport, writeSupervisorRunReportSafe };
 
 //# sourceMappingURL=index.js.map