@tangle-network/agent-eval 0.221.7 → 0.222.0

package/dist/{terminal-record-CB9BFtjS.js → rollout-nodes-BHR9Q5jP.js}

@@ -1,5 +1,7 @@
-import { n as isRecord } from "./json-BhdsJaOQ.js";
-//#region src/supervisor-run/journal-event-group.ts
+import { c as unscreenedRewardFields } from "./reward-P0VD_Aft.js";
+import { n as isRecord } from "./json-DtvZNAU9.js";
+import { r as ROLLOUT_SCHEMA, u as isRolloutLine } from "./schema-YUIXT8iW.js";
+// src/supervisor-run/journal-event-group.ts
 /** Expand a committed group only after every member is readable; never recover its prefix. */
 function expandJournalEventGroup(row) {
 	if (row.kind !== "events") return {
@@ -33,8 +35,7 @@ function expandJournalEventGroup(row) {
 		}))
 	};
 }
-//#endregion
-//#region src/supervisor-run/types.ts
+// src/supervisor-run/types.ts
 function unavailable(reason) {
 	return { unavailable: reason };
 }
@@ -57,8 +58,7 @@ const NO_SOURCE_LIMITS = {
 };
 const SUPERVISOR_RUN_SCHEMA = "tangle.supervisor-run@1";
 const SUPERVISOR_RUN_ROLLUP_SCHEMA = "tangle.supervisor-run-rollup@1";
-//#endregion
-//#region src/supervisor-run/source-facts.ts
+// src/supervisor-run/source-facts.ts
 function asRecord(v) {
 	return typeof v === "object" && v !== null ? v : {};
 }
@@ -586,8 +586,7 @@ function nonEmptyString(value) {
 function recordOrNull(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
-//#endregion
-//#region src/supervisor-run/terminal-record.ts
+// src/supervisor-run/terminal-record.ts
 /**
 * The run's terminal record, read from the documents the store wrote when the
 * run ended. Runtime's own record outranks every other source: `result.json` is
@@ -648,7 +647,348 @@ function readTerminalRecord(input) {
 		completed: null
 	};
 }
-//#endregion
-export { expandJournalEventGroup as _, nonEmptyString as a, parseSupervisorTree as c, NO_SOURCE_LIMITS as d, SUPERVISOR_RUN_ROLLUP_SCHEMA as f, unavailable as g, showMeasured as h, asRecord as i, recordOrNull as l, isUnavailable as m, RUNTIME_FAILED_STATUS as n, parseJsonRecord as o, SUPERVISOR_RUN_SCHEMA as p, readTerminalRecord as r, parseJsonl as s, NO_TERMINAL_RECORD as t, workerSourceKey as u };
+// src/supervisor-run/rollout-nodes.ts
+/**
+* The supervision tree as `tangle.rollout.v1` rows.
+*
+* A supervisor run IS a tree of rollouts, so its nodes are not a new shape:
+* the root becomes one `RolloutLine` with `role: 'supervisor'`, and every
+* spawned invocation keeps its explicit supervisor/worker role with
+* `parent_rollout_id` pointing at its spawner. The rows append to the same
+* ledger as solo-agent rollouts and join to them with the same keys.
+*
+* What the journal CANNOT supply is the transcript: a worker's messages live
+* in its harness store (opencode sqlite, Claude Code jsonl), which the
+* `src/rollout/readers/*` intake readers own. Rows minted here are therefore
+* GAP lines (`messages: []`, `provenance.gap` set) carrying identity,
+* structure, outcome and cost. Runtime workspace receipts remain attached in
+* `provenance.workspace_captures`; their archives stay at the recorded refs.
+* Hydrating messages is the intake readers' job, keyed on `artifacts.transcript_ref`.
+*
+* Timing lives in `outcome.metrics` (`spawned_at` / `settled_at` / `wall_ms`)
+* rather than a schema field: `tangle.rollout.v1` describes ONE invocation,
+* and the inter-invocation event timeline — which is what waves, concurrency,
+* idle and utilization are computed from — is a property of the journal, not
+* of any single row. The analyzer reads that timeline; these rows carry the
+* per-node facts.
+*/
+const EMPTY_COST = {
+	usd: null,
+	tokens_in: null,
+	tokens_out: null,
+	tokens_reasoning: null,
+	cache_read: null,
+	cache_write: null,
+	wall_s: null
+};
+function hasWorkerId(worker) {
+	return worker.workerId !== void 0;
+}
+/**
+* Mint the supervision tree as rollout rows. Returns the rows plus the gaps
+* that made any of them incomplete — same unavailable-vs-zero discipline as
+* the report: a row with no transcript says WHY, it never pretends to be empty.
+*/
+function supervisorRunRolloutLines(src, opts = {}) {
+	return supervisorRunRolloutLinesFromFacts(src, parseSupervisorTree(src), opts);
+}
+/** What the root and worker rows share: the parsed run record, the row template and the gap collector. */
+function rolloutContext(src, tree, opts, gaps) {
+	const state = tree.state;
+	const result = parseJsonRecord(src.result);
+	const judge = parseJsonRecord(src.judge);
+	const stateResult = asRecord(state?.result);
+	const terminal = readTerminalRecord({
+		state,
+		result,
+		failure: src.failure === void 0 ? void 0 : parseJsonRecord(src.failure)
+	});
+	const rootId = tree.rootId;
+	const runId = opts.runId ?? rootId ?? src.runRef;
+	const suite = opts.suite ?? "supervisor-run";
+	const instanceId = src.instanceId ?? src.runRef;
+	const split = opts.split ?? "search";
+	const capturedAt = opts.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const base = {
+		schema: ROLLOUT_SCHEMA,
+		run_id: runId,
+		experiment_id: opts.experimentId ?? null,
+		candidate_id: opts.candidateId ?? null,
+		generation: opts.generation ?? null,
+		candidate_index: opts.candidateIndex ?? null,
+		task: {
+			suite,
+			instance_id: instanceId,
+			split,
+			seed: opts.seed ?? null,
+			rep: opts.rep ?? 0
+		},
+		messages: [],
+		tool_defs: []
+	};
+	const noteCaptureGaps = (owner, nodeId, captures) => {
+		if (captures === null || captures?.length === 0) {
+			gaps.push({
+				code: "workspace-capture-unavailable",
+				message: `${owner} has no retained output capture evidence`,
+				nodeId
+			});
+			return "workspace capture evidence unavailable";
+		}
+		let incomplete = false;
+		for (const [index, capture] of captures?.entries() ?? []) {
+			const reasons = [capture.projectionGap, capture.coverageComplete === false ? capture.incompleteReason ?? "provider reported incomplete coverage" : capture.coverageComplete === null ? "capture coverage was not recorded" : null].filter((reason) => reason !== null);
+			if (reasons.length > 0) {
+				incomplete = true;
+				gaps.push({
+					code: "workspace-capture-incomplete",
+					message: `${owner} result ${index + 1}: ${reasons.join("; ")}`,
+					nodeId
+				});
+			}
+		}
+		return incomplete ? "workspace capture evidence incomplete" : null;
+	};
+	return {
+		src,
+		tree,
+		opts,
+		gaps,
+		state,
+		result,
+		judge,
+		stateResult,
+		terminal,
+		rootId,
+		capturedAt,
+		base,
+		noteCaptureGaps
+	};
+}
+/** The supervisor invocation row, or nothing when the journal never named a root. */
+function rootRolloutNode(ctx) {
+	const { src, tree, opts, gaps, state, result, judge, stateResult, terminal, rootId, capturedAt, noteCaptureGaps, base } = ctx;
+	if (rootId === null) {
+		gaps.push({
+			code: "root-spawn-unavailable",
+			message: "no parentless spawned event in the journal"
+		});
+		return null;
+	}
+	const rootSpawn = tree.spawns.find((spawn) => spawn.valid && spawn.id === rootId);
+	const judgeResolved = typeof judge?.resolved === "boolean" ? judge.resolved : null;
+	const reward = (typeof judge?.score === "number" ? judge.score : null) ?? (judgeResolved === null ? null : judgeResolved ? 1 : 0);
+	if (reward === null) gaps.push({
+		code: "root-reward-unavailable",
+		message: "no judge verdict for this run",
+		nodeId: rootId
+	});
+	const wallMs = tree.startedAt !== null && tree.completedAt !== null && tree.completedAt >= tree.startedAt ? tree.completedAt - tree.startedAt : null;
+	const captures = src.rootWorkspaceCaptures;
+	const captureGap = noteCaptureGaps(`root ${JSON.stringify(rootId)}`, rootId, captures);
+	return {
+		...base,
+		rollout_id: rootId,
+		parent_rollout_id: null,
+		role: rootSpawn?.role ?? "supervisor",
+		policy: {
+			harness: opts.supervisorHarness ?? null,
+			harness_version: null,
+			model: opts.supervisorModel ?? null,
+			provider: null,
+			profile_commit: null,
+			agent_profile_cell_id: rootSpawn?.profileDigest ?? null,
+			sampling: null
+		},
+		outcome: {
+			...unscreenedRewardFields(reward),
+			reward_source: src.judgeSource,
+			verdict: judge ?? null,
+			metrics: {
+				arm: src.arm,
+				sup_status: isUnavailable(terminal.supStatus) ? null : terminal.supStatus,
+				sup_verdict: typeof state?.verdict === "string" ? state.verdict : null,
+				delivered: typeof stateResult.delivered === "boolean" ? stateResult.delivered : null,
+				verify_pass: typeof result?.verify_pass === "boolean" ? result.verify_pass : null,
+				started_at: tree.startedAt,
+				completed_at: tree.completedAt,
+				workers_spawned: tree.workerSpawns.length,
+				brain_metered_events: tree.brain.meteredCount,
+				runtime: rootSpawn?.runtime ?? null,
+				profile_digest: rootSpawn?.profileDigest ?? null
+			},
+			is_completed: terminal.completed === true,
+			is_truncated: false,
+			error: terminal.completed !== false ? null : !isUnavailable(terminal.supReason) && terminal.supReason !== null ? terminal.supReason : !isUnavailable(terminal.failure) && terminal.failure !== null ? terminal.failure.message ?? terminal.failure.name : null,
+			realness_gated: false
+		},
+		cost: {
+			...EMPTY_COST,
+			usd: src.limits.spendUsd !== null ? null : typeof stateResult.spentUsd === "number" ? stateResult.spentUsd : tree.brain.usd,
+			tokens_in: src.limits.managerTokens === null ? tree.brain.tokensIn : null,
+			tokens_out: src.limits.managerTokens === null ? tree.brain.tokensOut : null,
+			cache_read: src.limits.managerTokens === null && tree.brain.hasCache ? tree.brain.cacheRead : null,
+			cache_write: src.limits.managerTokens === null && tree.brain.hasCache ? tree.brain.cacheWrite : null,
+			wall_s: wallMs === null ? null : wallMs / 1e3
+		},
+		artifacts: {
+			patch_path: typeof result?.patchPath === "string" ? result.patchPath : null,
+			run_dir: src.supRunDir,
+			transcript_ref: src.rootTranscriptRef ?? null
+		},
+		provenance: {
+			captured_at: capturedAt,
+			capture: "backfill",
+			lossy_projection: true,
+			...captures === void 0 ? {} : { workspace_captures: captures },
+			gap: [src.rootTranscriptRef == null ? "supervision journal carries structure and spend, not the brain transcript" : "brain transcript retained by reference; messages not inlined into this row", captureGap].filter((reason) => reason !== null).join("; ")
+		}
+	};
+}
+/** The journal closes and the reader's worker sources, joined to spawns by stable id first and by label only as a fallback. */
+function workerLookups(ctx) {
+	const { src, tree } = ctx;
+	return {
+		closeById: new Map(tree.closes.map((c) => [c.id, c])),
+		sourceById: new Map((src.workers ?? []).filter(hasWorkerId).map((worker) => [worker.workerId, worker])),
+		fallbackSourceByLabel: new Map((src.workers ?? []).filter((worker) => worker.workerId === void 0).map((worker) => [worker.label, worker]))
+	};
+}
+/** One worker row, or nothing when its spawn has no explicit role. */
+function workerRolloutNode(ctx, lookups, spawn) {
+	const { src, tree, opts, gaps, capturedAt, noteCaptureGaps, base } = ctx;
+	const { closeById, sourceById, fallbackSourceByLabel } = lookups;
+	if (spawn.role === null) {
+		gaps.push({
+			code: "node-role-unavailable",
+			message: `child ${JSON.stringify(spawn.label)} has no explicit invocation role`,
+			nodeId: spawn.id
+		});
+		return null;
+	}
+	const close = closeById.get(spawn.id) ?? null;
+	const workerSource = sourceById.get(spawn.id) ?? fallbackSourceByLabel.get(spawn.label) ?? null;
+	const facts = tree.workerLogs.get(workerSource?.workerId ?? workerSource?.label ?? spawn.label) ?? null;
+	const wallMs = facts?.started != null && facts.finishedAt != null ? facts.finishedAt - facts.started : null;
+	const score = close?.score ?? facts?.score ?? null;
+	const passed = close?.valid ?? facts?.passed ?? null;
+	const reward = score ?? (passed === null ? null : passed ? 1 : 0);
+	if (reward === null) gaps.push({
+		code: "child-reward-unavailable",
+		message: `child ${JSON.stringify(spawn.label)} has no verify verdict`,
+		nodeId: spawn.id
+	});
+	const isSupervisor = spawn.role === "supervisor";
+	const captures = workerSource?.workspaceCaptures;
+	const captureGap = noteCaptureGaps(`child ${JSON.stringify(spawn.label)}`, spawn.id, captures);
+	return {
+		...base,
+		rollout_id: spawn.id,
+		parent_rollout_id: spawn.parent,
+		role: spawn.role,
+		policy: {
+			harness: isSupervisor ? opts.supervisorHarness ?? null : opts.workerHarness ?? null,
+			harness_version: null,
+			model: isSupervisor ? opts.supervisorModel ?? null : opts.workerModel ?? null,
+			provider: null,
+			profile_commit: null,
+			agent_profile_cell_id: spawn.profileDigest,
+			sampling: null
+		},
+		outcome: {
+			...unscreenedRewardFields(reward),
+			reward_source: reward === null ? null : score === null ? "worker-self-verify" : "worker-verdict-score",
+			verdict: close === null ? null : {
+				kind: close.kind,
+				status: close.status,
+				verdict: close.rawVerdict,
+				valid: close.valid,
+				score: close.score
+			},
+			metrics: {
+				label: spawn.label,
+				spawned_at: spawn.at,
+				settled_at: close?.at ?? null,
+				started_at: facts?.started ?? null,
+				finished_at: facts?.finishedAt ?? null,
+				wall_ms: wallMs,
+				patch_bytes: workerSource?.patchBytes ?? facts?.finishedPatchBytes ?? null,
+				evidence_bytes: facts?.evidenceBytes ?? null,
+				steers_queued: facts?.steersQueued ?? null,
+				steers_delivered: facts?.steersDelivered ?? null,
+				questions: facts?.questions ?? null,
+				runtime: spawn.runtime,
+				profile_digest: spawn.profileDigest
+			},
+			is_completed: close?.kind === "settled" && close.status === "done",
+			is_truncated: close?.kind === "cancelled",
+			error: close?.kind === "cancelled" ? close.reason ?? "cancelled" : close?.status === "down" ? close.reason ?? "child down" : null,
+			realness_gated: false
+		},
+		cost: {
+			...EMPTY_COST,
+			usd: src.limits.spendUsd !== null || !close?.hasSpend ? null : close.spend.usd,
+			tokens_in: workerSource?.tokensIn ?? (close?.hasSpend ? close.spend.tokens.input : null),
+			tokens_out: workerSource?.tokensOut ?? (close?.hasSpend ? close.spend.tokens.output : null),
+			cache_read: workerSource?.cacheRead ?? (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheRead : null),
+			cache_write: workerSource?.cacheWrite ?? (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheWrite : null),
+			wall_s: wallMs === null ? null : wallMs / 1e3
+		},
+		artifacts: {
+			patch_path: workerSource?.patchPath ?? null,
+			run_dir: src.supRunDir,
+			transcript_ref: workerSource?.transcriptRef ?? null
+		},
+		provenance: {
+			captured_at: capturedAt,
+			capture: "backfill",
+			lossy_projection: true,
+			...captures === void 0 ? {} : { workspace_captures: captures },
+			gap: [workerSource?.transcriptRef == null ? "no worker transcript was retained; messages unavailable" : "worker transcript retained by reference; messages not inlined into this row", captureGap].filter((reason) => reason !== null).join("; ")
+		}
+	};
+}
+/** Mint rollout rows from an already parsed source without reading its JSONL again. */
+function supervisorRunRolloutLinesFromFacts(src, tree, opts = {}) {
+	const gaps = [];
+	if (src.journal === null) {
+		gaps.push({
+			code: "journal-unavailable",
+			message: `${src.supRunDir === null ? "no supervisor run dir" : "journal absent"}; no nodes recoverable`
+		});
+		return {
+			rootId: null,
+			nodes: [],
+			gaps
+		};
+	}
+	const malformedSourceRows = tree.journalInvalidRows + tree.spawns.filter((spawn) => !spawn.valid).length;
+	if (malformedSourceRows > 0) gaps.push({
+		code: "source-row-malformed",
+		message: `${malformedSourceRows} of ${tree.journalRows} journal row(s) were unusable and excluded from the tree`,
+		count: malformedSourceRows
+	});
+	const ctx = rolloutContext(src, tree, opts, gaps);
+	const nodes = [];
+	const root = rootRolloutNode(ctx);
+	if (root) nodes.push(root);
+	const lookups = workerLookups(ctx);
+	for (const spawn of tree.workerSpawns) {
+		const node = workerRolloutNode(ctx, lookups, spawn);
+		if (node) nodes.push(node);
+	}
+	const invalid = nodes.filter((n) => !isRolloutLine(n));
+	if (invalid.length > 0) gaps.push({
+		code: "node-schema-invalid",
+		message: `${invalid.length} node(s) failed tangle.rollout.v1 validation`,
+		count: invalid.length
+	});
+	return {
+		rootId: tree.rootId,
+		nodes,
+		gaps
+	};
+}
+export { showMeasured as _, readTerminalRecord as a, parseJsonRecord as c, recordOrNull as d, workerSourceKey as f, isUnavailable as g, SUPERVISOR_RUN_SCHEMA as h, RUNTIME_FAILED_STATUS as i, parseJsonl as l, SUPERVISOR_RUN_ROLLUP_SCHEMA as m, supervisorRunRolloutLinesFromFacts as n, asRecord as o, NO_SOURCE_LIMITS as p, NO_TERMINAL_RECORD as r, nonEmptyString as s, supervisorRunRolloutLines as t, parseSupervisorTree as u, unavailable as v, expandJournalEventGroup as y };
 
-//# sourceMappingURL=terminal-record-CB9BFtjS.js.map
+//# sourceMappingURL=rollout-nodes-BHR9Q5jP.js.map