@tangle-network/agent-eval 0.174.0 → 0.176.0

package/dist/terminal-record-Ce9_UjRz.js

@@ -0,0 +1,539 @@
+//#region src/supervisor-run/source-facts.ts
+function asRecord(v) {
+	return typeof v === "object" && v !== null ? v : {};
+}
+function num(v) {
+	return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function readSpend(v) {
+	const rec = asRecord(v);
+	const tok = asRecord(rec.tokens);
+	const cacheRead = tok.cacheRead ?? tok.cache_read;
+	const cacheWrite = tok.cacheWrite ?? tok.cache_write;
+	return {
+		tokens: {
+			input: num(tok.input),
+			output: num(tok.output),
+			cacheRead: num(cacheRead),
+			cacheWrite: num(cacheWrite),
+			hasCache: cacheRead !== void 0 || cacheWrite !== void 0,
+			breakdownKnown: tok.cacheBreakdownKnown !== false
+		},
+		tokensKnown: rec.tokensKnown !== false,
+		usd: num(rec.usd),
+		usdKnown: rec.usdKnown !== false
+	};
+}
+function parseJsonl(text) {
+	return parseJsonlWithDiagnostics(text).rows;
+}
+function parseJsonlWithDiagnostics(text) {
+	if (text === null) return {
+		rows: [],
+		invalidRows: 0
+	};
+	const out = [];
+	let invalidRows = 0;
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) out.push(parsed);
+			else invalidRows += 1;
+		} catch {
+			invalidRows += 1;
+		}
+	}
+	return {
+		rows: out,
+		invalidRows
+	};
+}
+function parseJson(text) {
+	if (text === null) return null;
+	try {
+		const parsed = JSON.parse(text);
+		return typeof parsed === "object" && parsed !== null ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function ms(at) {
+	if (typeof at !== "string") return null;
+	const t = Date.parse(at);
+	return Number.isFinite(t) ? t : null;
+}
+function readVerdict(v) {
+	if (typeof v === "string") return {
+		label: v,
+		valid: null,
+		score: null,
+		raw: v
+	};
+	if (typeof v !== "object" || v === null) return {
+		label: null,
+		valid: null,
+		score: null,
+		raw: null
+	};
+	const rec = v;
+	const valid = typeof rec.valid === "boolean" ? rec.valid : null;
+	return {
+		label: valid === null ? null : valid ? "valid" : "invalid",
+		valid,
+		score: typeof rec.score === "number" && Number.isFinite(rec.score) ? rec.score : null,
+		raw: v
+	};
+}
+function workerSourceKey(worker) {
+	return worker.workerId ?? worker.label;
+}
+/** Event kinds this parser folds into the tree. */
+const TREE_EVENT_KINDS = [
+	"spawned",
+	"settled",
+	"cancelled",
+	"metered"
+];
+/**
+* Event kinds `agent-runtime` journals that this parser recognizes but does not model as
+* tree nodes: `waiting` arms a wait node and `woken` settles it. They are counted by kind
+* rather than dropped, so "understood, not modeled" can never be mistaken for "absent".
+*/
+const UNMODELLED_EVENT_KINDS = ["waiting", "woken"];
+function treeEventKind(value) {
+	return TREE_EVENT_KINDS.includes(value) ? value : null;
+}
+/**
+* Classify one parsed journal row. Every row lands in exactly one outcome — interpreted,
+* recognized-but-not-modeled, or unreadable — because a row that falls through silently is
+* how a run with events reads as a run with none.
+*/
+function readJournalRow(row) {
+	const kind = row.kind;
+	if (typeof kind !== "string") return { outcome: "unreadable" };
+	if (kind === "begin" && typeof row.root === "string") return {
+		outcome: "ignored",
+		dialect: "runtime-envelope",
+		kind: "begin"
+	};
+	if (kind === "event") {
+		const inner = row.event;
+		if (typeof inner !== "object" || inner === null || Array.isArray(inner)) return { outcome: "unreadable" };
+		const innerKind = inner.kind;
+		if (typeof innerKind !== "string") return { outcome: "unreadable" };
+		const tree = treeEventKind(innerKind);
+		if (tree !== null) return {
+			outcome: "event",
+			dialect: "runtime-envelope",
+			kind: tree,
+			event: inner
+		};
+		return {
+			outcome: "ignored",
+			dialect: "runtime-envelope",
+			kind: innerKind
+		};
+	}
+	const tree = treeEventKind(kind);
+	if (tree !== null) return {
+		outcome: "event",
+		dialect: "flat",
+		kind: tree,
+		event: row
+	};
+	if (UNMODELLED_EVENT_KINDS.includes(kind)) return {
+		outcome: "ignored",
+		dialect: "flat",
+		kind
+	};
+	return { outcome: "unreadable" };
+}
+function summarizeDialect(seen) {
+	if (seen.size === 0) return "none";
+	if (seen.size > 1) return "mixed";
+	return seen.has("runtime-envelope") ? "runtime-envelope" : "flat";
+}
+function parseSupervisorTree(src) {
+	const parsedJournal = parseJsonlWithDiagnostics(src.journal);
+	const events = parsedJournal.rows;
+	const state = parseJson(src.state);
+	const spawns = [];
+	const closes = [];
+	let brainIn = 0;
+	let brainOut = 0;
+	let brainCacheRead = 0;
+	let brainCacheWrite = 0;
+	let brainHasCache = false;
+	let brainCacheBreakdownKnown = true;
+	let brainTokensKnownCount = 0;
+	let brainTokensUnknownCount = 0;
+	let brainUsd = 0;
+	let brainUsdKnownCount = 0;
+	let brainUsdUnknownCount = 0;
+	let meteredCount = 0;
+	let rootId = null;
+	let unreadableRows = 0;
+	const ignoredByKind = /* @__PURE__ */ new Map();
+	const dialectsSeen = /* @__PURE__ */ new Set();
+	const meteredRows = [];
+	for (const [sourceRow, row] of events.entries()) {
+		const reading = readJournalRow(row);
+		if (reading.outcome === "unreadable") {
+			unreadableRows += 1;
+			continue;
+		}
+		dialectsSeen.add(reading.dialect);
+		if (reading.outcome === "ignored") {
+			ignoredByKind.set(reading.kind, (ignoredByKind.get(reading.kind) ?? 0) + 1);
+			continue;
+		}
+		const { kind, event: ev } = reading;
+		const id = typeof ev.id === "string" ? ev.id : "";
+		if (kind === "spawned") {
+			const parent = typeof ev.parent === "string" && ev.parent.length > 0 ? ev.parent : null;
+			const label = typeof ev.label === "string" ? ev.label : "";
+			const invalidFields = [];
+			if (id.length === 0) invalidFields.push("id");
+			const parentOmittedForFirstRoot = ev.parent === void 0 && rootId === null;
+			if (ev.parent !== null && !parentOmittedForFirstRoot && !(typeof ev.parent === "string" && ev.parent.length > 0)) invalidFields.push("parent");
+			if (label.length === 0) invalidFields.push("label");
+			if (ev.role !== void 0 && ev.role !== "supervisor" && ev.role !== "worker") invalidFields.push("role");
+			if (ev.profileDigest !== void 0 && !(typeof ev.profileDigest === "string" && ev.profileDigest.length > 0)) invalidFields.push("profileDigest");
+			if (ev.runtime !== void 0 && !(typeof ev.runtime === "string" && ev.runtime.length > 0)) invalidFields.push("runtime");
+			const role = ev.role === "supervisor" || ev.role === "worker" ? ev.role : null;
+			const valid = invalidFields.length === 0;
+			if (valid && parent === null && rootId === null) rootId = id;
+			spawns.push({
+				sourceRow,
+				id,
+				parent,
+				label,
+				role,
+				profileDigest: typeof ev.profileDigest === "string" && ev.profileDigest.length > 0 ? ev.profileDigest : null,
+				runtime: typeof ev.runtime === "string" && ev.runtime.length > 0 ? ev.runtime : null,
+				at: ms(ev.at),
+				valid,
+				invalidFields
+			});
+		} else if (kind === "settled") {
+			const verdict = readVerdict(ev.verdict);
+			closes.push({
+				id,
+				kind: "settled",
+				status: typeof ev.status === "string" ? ev.status : null,
+				verdict: verdict.label,
+				valid: verdict.valid,
+				score: verdict.score,
+				rawVerdict: verdict.raw,
+				reason: typeof ev.reason === "string" ? ev.reason : null,
+				infra: typeof ev.infra === "boolean" ? ev.infra : null,
+				at: ms(ev.at),
+				spend: readSpend(ev.spent),
+				hasSpend: asRecord(ev.spent).tokens !== void 0
+			});
+		} else if (kind === "cancelled") closes.push({
+			id,
+			kind: "cancelled",
+			status: "cancelled",
+			verdict: typeof ev.reason === "string" ? ev.reason : null,
+			valid: null,
+			score: null,
+			rawVerdict: typeof ev.reason === "string" ? ev.reason : null,
+			reason: typeof ev.reason === "string" ? ev.reason : null,
+			infra: null,
+			at: ms(ev.at),
+			spend: {
+				tokens: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					hasCache: false,
+					breakdownKnown: true
+				},
+				tokensKnown: true,
+				usd: 0,
+				usdKnown: true
+			},
+			hasSpend: false
+		});
+		else if (kind === "metered") meteredRows.push({
+			id,
+			spend: readSpend(ev.spend),
+			at: ms(ev.at)
+		});
+		else throw new Error(`unhandled journal event kind ${JSON.stringify(kind)}`);
+	}
+	for (const row of meteredRows) {
+		if (rootId === null || row.id !== rootId) continue;
+		if (row.spend.tokensKnown) {
+			brainIn += row.spend.tokens.input;
+			brainOut += row.spend.tokens.output;
+			brainCacheRead += row.spend.tokens.cacheRead;
+			brainCacheWrite += row.spend.tokens.cacheWrite;
+			brainHasCache = brainHasCache || row.spend.tokens.hasCache;
+			brainCacheBreakdownKnown = brainCacheBreakdownKnown && row.spend.tokens.breakdownKnown;
+			brainTokensKnownCount += 1;
+		} else brainTokensUnknownCount += 1;
+		if (row.spend.usdKnown) {
+			brainUsd += row.spend.usd;
+			brainUsdKnownCount += 1;
+		} else brainUsdUnknownCount += 1;
+		meteredCount += 1;
+	}
+	const workerSpawns = spawns.filter((s) => s.valid && s.id !== rootId);
+	const workerIds = new Set(workerSpawns.map((s) => s.id));
+	const workerCloses = closes.filter((c) => workerIds.has(c.id));
+	const workerLogs = /* @__PURE__ */ new Map();
+	const workerLogRows = [];
+	for (const [sourceIndex, w] of (src.workers ?? []).entries()) {
+		const facts = {
+			sourceIndex,
+			workerId: w.workerId ?? null,
+			label: w.label,
+			inboxCaptured: w.inbox !== null,
+			eventsCaptured: w.events !== null,
+			inboxInvalidRows: 0,
+			eventsInvalidRows: 0,
+			started: null,
+			finished: false,
+			finishedAt: null,
+			passed: null,
+			score: null,
+			finishedPatchBytes: null,
+			evidenceBytes: 0,
+			steersQueued: null,
+			steersDelivered: null,
+			steersQueuedUnavailable: null,
+			steersDeliveredUnavailable: null,
+			questions: 0,
+			steerRequests: [],
+			steerAcknowledgements: []
+		};
+		const parsedInbox = parseJsonlWithDiagnostics(w.inbox);
+		const parsedEvents = parseJsonlWithDiagnostics(w.events);
+		facts.inboxInvalidRows = parsedInbox.invalidRows;
+		facts.eventsInvalidRows = parsedEvents.invalidRows;
+		for (const [row, req] of parsedInbox.rows.entries()) {
+			if (typeof req.message !== "string" || req.message.trim().length === 0) continue;
+			facts.steerRequests.push({
+				requestId: typeof req.id === "string" && req.id.length > 0 ? req.id : null,
+				row
+			});
+		}
+		for (const [row, ev] of parsedEvents.rows.entries()) {
+			const kind = ev.kind;
+			if (kind === "message") {
+				if (ev.direction === "up") {
+					facts.questions += 1;
+					continue;
+				}
+				facts.steerAcknowledgements.push({
+					requestId: typeof ev.requestId === "string" && ev.requestId.length > 0 ? ev.requestId : null,
+					delivered: typeof ev.delivered === "boolean" ? ev.delivered : null,
+					row
+				});
+			} else if (kind === "started") facts.started = ms(ev.at);
+			else if (kind === "finished") {
+				facts.finished = true;
+				facts.finishedAt = ms(ev.at);
+				facts.passed = typeof ev.passed === "boolean" ? ev.passed : null;
+				facts.score = typeof ev.score === "number" && Number.isFinite(ev.score) ? ev.score : null;
+				facts.finishedPatchBytes = typeof ev.patchBytes === "number" ? ev.patchBytes : null;
+				facts.evidenceBytes = typeof ev.evidence === "string" ? ev.evidence.length : 0;
+			}
+		}
+		const requestsById = /* @__PURE__ */ new Map();
+		for (const request of facts.steerRequests) {
+			if (request.requestId === null) continue;
+			requestsById.set(request.requestId, (requestsById.get(request.requestId) ?? 0) + 1);
+		}
+		const acknowledgementsById = /* @__PURE__ */ new Map();
+		for (const acknowledgement of facts.steerAcknowledgements) {
+			if (acknowledgement.requestId === null) continue;
+			const matches = acknowledgementsById.get(acknowledgement.requestId) ?? [];
+			matches.push(acknowledgement);
+			acknowledgementsById.set(acknowledgement.requestId, matches);
+		}
+		const queueProblems = [];
+		if (!facts.inboxCaptured) queueProblems.push("inbox absent");
+		if (!facts.eventsCaptured) queueProblems.push("events absent");
+		if (facts.inboxInvalidRows > 0) queueProblems.push("inbox contains malformed rows");
+		if (facts.eventsInvalidRows > 0) queueProblems.push("events contain malformed rows");
+		if (facts.steerRequests.some((request) => request.requestId === null)) queueProblems.push("queued request id missing");
+		if ([...requestsById.values()].some((count) => count > 1)) queueProblems.push("queued request id duplicated");
+		if (facts.steerAcknowledgements.some((acknowledgement) => acknowledgement.requestId === null)) queueProblems.push("acknowledgement request id missing");
+		if ([...acknowledgementsById.keys()].some((id) => !requestsById.has(id))) queueProblems.push("acknowledgement has no queued request");
+		if (queueProblems.length === 0) facts.steersQueued = requestsById.size;
+		else facts.steersQueuedUnavailable = [...new Set(queueProblems)].join("; ");
+		const deliveryProblems = [...queueProblems];
+		if ([...acknowledgementsById.values()].some((rows) => rows.length > 1)) deliveryProblems.push("acknowledgement request id duplicated");
+		if (facts.steerAcknowledgements.some((acknowledgement) => acknowledgement.delivered === null)) deliveryProblems.push("acknowledgement delivery status missing");
+		if (deliveryProblems.length === 0) facts.steersDelivered = [...requestsById.keys()].filter((id) => {
+			const acknowledgement = acknowledgementsById.get(id);
+			return acknowledgement?.length === 1 && acknowledgement[0]?.delivered === true;
+		}).length;
+		else facts.steersDeliveredUnavailable = [...new Set(deliveryProblems)].join("; ");
+		workerLogRows.push(facts);
+		workerLogs.set(workerSourceKey(w), facts);
+	}
+	const startedAt = ms(state?.startedAt) ?? spawns[0]?.at ?? null;
+	const rootClose = rootId === null ? null : closes.find((close) => close.id === rootId);
+	const completedAt = ms(state?.completedAt) ?? rootClose?.at ?? null;
+	let firstEventAt = null;
+	let lastEventAt = null;
+	const widenEventSpan = (at) => {
+		if (at === null) return;
+		if (firstEventAt === null || at < firstEventAt) firstEventAt = at;
+		if (lastEventAt === null || at > lastEventAt) lastEventAt = at;
+	};
+	for (const spawn of spawns) widenEventSpan(spawn.at);
+	for (const close of closes) widenEventSpan(close.at);
+	for (const metered of meteredRows) widenEventSpan(metered.at);
+	return {
+		rootId,
+		spawns,
+		closes,
+		workerSpawns,
+		workerCloses,
+		brain: {
+			tokensIn: brainIn,
+			tokensOut: brainOut,
+			cacheRead: brainCacheRead,
+			cacheWrite: brainCacheWrite,
+			hasCache: brainHasCache,
+			cacheBreakdownKnown: brainCacheBreakdownKnown,
+			tokensKnownCount: brainTokensKnownCount,
+			tokensUnknownCount: brainTokensUnknownCount,
+			usd: brainUsd,
+			usdKnownCount: brainUsdKnownCount,
+			usdUnknownCount: brainUsdUnknownCount,
+			meteredCount
+		},
+		workerLogs,
+		workerLogRows,
+		journalRows: events.length + parsedJournal.invalidRows,
+		journalInvalidRows: parsedJournal.invalidRows + unreadableRows,
+		journalMalformedJsonRows: parsedJournal.invalidRows,
+		journalIgnoredRowsByKind: Object.fromEntries(ignoredByKind),
+		journalMeteredRows: meteredRows.length,
+		journalDialect: summarizeDialect(dialectsSeen),
+		state,
+		startedAt,
+		completedAt,
+		firstEventAt,
+		lastEventAt
+	};
+}
+//#endregion
+//#region src/supervisor-run/types.ts
+function unavailable(reason) {
+	return { unavailable: reason };
+}
+function isUnavailable(v) {
+	return typeof v === "object" && v !== null && typeof v.unavailable === "string";
+}
+/** Render a measured scalar for the markdown/headline: `0` and `unavailable` stay distinct. */
+function showMeasured(v) {
+	if (isUnavailable(v)) return `unavailable — ${v.unavailable}`;
+	if (v === null) return "null";
+	return String(v);
+}
+/** A source that carries every fact the analyzer can use. */
+const NO_SOURCE_LIMITS = {
+	managerTokens: null,
+	workerTokens: null,
+	spendUsd: null,
+	workerVerdicts: null,
+	deliverables: null
+};
+const SUPERVISOR_RUN_SCHEMA = "tangle.supervisor-run@1";
+const SUPERVISOR_RUN_ROLLUP_SCHEMA = "tangle.supervisor-run-rollup@1";
+//#endregion
+//#region 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
+* the `SupervisedResult` that `supervise()` returned, verbatim, and its `kind`
+* is the run's status. `failure.json` is the record Runtime writes when
+* `supervise()` threw before a result landed. The control-plane-era loops
+* documents (`state.json` `status`, `result.json` `sup_status`) stay readable
+* as named legacy sources, so a report always says which record it read.
+*
+* Pure: takes already-parsed documents and returns `Measured` values. The
+* analyzer and the rollout minter share it so a run never has two statuses.
+*/
+/** The reason every terminal field reads `unavailable` when no store wrote one. */
+const NO_TERMINAL_RECORD = "no terminal record: Runtime result.json kind, Runtime failure.json, or legacy state.json / result.json status";
+/** The status reported for a run whose directory holds Runtime's failure record and no result. */
+const RUNTIME_FAILED_STATUS = "failed";
+function str(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function errorRecord(doc, source, earlierAttempt) {
+	if (typeof doc.error !== "object" || doc.error === null) return null;
+	const error = asRecord(doc.error);
+	return {
+		source,
+		name: str(error.name),
+		message: str(error.message),
+		at: str(doc.at),
+		earlierAttempt
+	};
+}
+function readTerminalRecord(input) {
+	const { state, result } = input;
+	const resultKind = str(result?.kind);
+	const settled = resultKind !== null && result !== null;
+	const failureRecord = input.failure === null || input.failure === void 0 ? null : errorRecord(input.failure, "runtime-failure", settled);
+	if (settled) return {
+		supStatus: resultKind,
+		supStatusSource: "runtime-result",
+		supReason: str(result.reason),
+		failure: failureRecord ?? errorRecord(result, "runtime-result", false),
+		completed: resultKind === "winner"
+	};
+	if (failureRecord !== null) return {
+		supStatus: RUNTIME_FAILED_STATUS,
+		supStatusSource: "runtime-failure",
+		supReason: null,
+		failure: failureRecord,
+		completed: false
+	};
+	if (input.failure !== null && input.failure !== void 0) return {
+		supStatus: RUNTIME_FAILED_STATUS,
+		supStatusSource: "runtime-failure",
+		supReason: null,
+		failure: unavailable("Runtime failure.json carries no error record"),
+		completed: false
+	};
+	const legacyStateStatus = str(state?.status);
+	if (legacyStateStatus !== null) return {
+		supStatus: legacyStateStatus,
+		supStatusSource: "legacy-state",
+		supReason: null,
+		failure: unavailable("legacy state.json records no failure document"),
+		completed: legacyStateStatus === "completed"
+	};
+	const legacyResultStatus = str(result?.sup_status);
+	if (legacyResultStatus !== null) return {
+		supStatus: legacyResultStatus,
+		supStatusSource: "legacy-result",
+		supReason: null,
+		failure: unavailable("legacy result.json records no failure document"),
+		completed: legacyResultStatus === "completed"
+	};
+	return {
+		supStatus: unavailable(NO_TERMINAL_RECORD),
+		supStatusSource: unavailable(NO_TERMINAL_RECORD),
+		supReason: unavailable(NO_TERMINAL_RECORD),
+		failure: unavailable(NO_TERMINAL_RECORD),
+		completed: null
+	};
+}
+//#endregion
+export { SUPERVISOR_RUN_ROLLUP_SCHEMA as a, showMeasured as c, parseJson as d, parseJsonl as f, NO_SOURCE_LIMITS as i, unavailable as l, workerSourceKey as m, RUNTIME_FAILED_STATUS as n, SUPERVISOR_RUN_SCHEMA as o, parseSupervisorTree as p, readTerminalRecord as r, isUnavailable as s, NO_TERMINAL_RECORD as t, asRecord as u };
+
+//# sourceMappingURL=terminal-record-Ce9_UjRz.js.map