@tangle-network/sandbox-cli 0.21.23 → 0.21.25

package/dist/graph-viewer/agent-runtime.js

@@ -0,0 +1,2293 @@
+import { recordSchema as e } from "./record.js";
+import { t } from "./part-events-BrLrg_EV.js";
+import { n, t as r } from "./anchor-C4i5SrB9.js";
+import { createHash as i } from "node:crypto";
+import { closeSync as a, copyFileSync as o, existsSync as s, mkdtempSync as c, openSync as l, readFileSync as u, readSync as d, readdirSync as f, rmSync as p, statSync as m } from "node:fs";
+import { tmpdir as h } from "node:os";
+import { basename as g, dirname as _, join as v } from "node:path";
+//#region src/adapters/agent-runtime.ts
+var y = "2.7.0", b = 134217728;
+function x({ maxBytes: e = 1073741824 } = {}) {
+	let t = /* @__PURE__ */ new Map(), n = 0;
+	return {
+		read(r) {
+			let i = m(r), a = `${i.dev}:${i.ino}:${i.size}:${i.mtimeMs}:${i.ctimeMs}`, o = t.get(r);
+			if (o && (t.delete(r), n -= o.bytes.length, o.key === a)) return t.set(r, o), n += o.bytes.length, o;
+			let s = u(r), c = {
+				key: a,
+				bytes: s,
+				sha256: T(s)
+			};
+			s.length <= e / 4 && (t.set(r, c), n += s.length);
+			for (let [r, i] of t) {
+				if (n <= e) break;
+				t.delete(r), n -= i.bytes.length;
+			}
+			return c;
+		},
+		heldBytes: () => n
+	};
+}
+var S = class extends Error {
+	exitCode = 2;
+}, C = class extends Error {
+	exitCode = 3;
+	code = "record-too-large";
+}, w = class extends Error {
+	exitCode = 4;
+}, T = (e) => i("sha256").update(e).digest("hex"), E = (e) => typeof e == "string" && /^(sha256[:-])?[0-9a-f]{64}$/.test(e) ? e.slice(-64) : null, D = /(^|\/)\.claude\/projects\/[^/]+\/[^/]+\.jsonl$/, O = (e) => D.test(e) ? e.slice(e.lastIndexOf(".claude/projects/")) : null, k = /(^|\/)\.local\/share\/opencode\/opencode\.db$/, A = "evidence/native-index.jsonl", j = "evidence/live-stream", M = Date.UTC(2001, 0, 1), N = Date.UTC(2100, 0, 1), P = (e) => {
+	if (typeof e != "string" && typeof e != "number") return null;
+	let t = new Date(typeof e == "number" && e < 1e11 ? e * 1e3 : e), n = t.valueOf();
+	return Number.isFinite(n) && n >= M && n < N ? t.toISOString() : null;
+};
+function F(e) {
+	if (e == null) return "null";
+	if (e === !0) return "true";
+	if (e === !1) return "false";
+	if (typeof e == "number") {
+		if (!Number.isFinite(e)) return e > 0 ? "Infinity" : e < 0 ? "-Infinity" : "NaN";
+		if (Number.isInteger(e) && Math.abs(e) < 0x2386f26fc10000) return String(e);
+		let [t, n] = e.toExponential().split("e");
+		return Number(n) >= -4 && Number(n) < 16 ? /[.e]/.test(String(e)) ? String(e) : `${e}.0` : `${t}e${n[0]}${n.slice(1).padStart(2, "0")}`;
+	}
+	if (typeof e == "string") {
+		let t = "\"";
+		for (let n = 0; n < e.length; n++) {
+			let r = e.charCodeAt(n), i = e[n];
+			t += i === "\"" ? "\\\"" : i === "\\" ? "\\\\" : i === "\n" ? "\\n" : i === "\r" ? "\\r" : i === "	" ? "\\t" : i === "\b" ? "\\b" : i === "\f" ? "\\f" : r < 32 || r > 126 ? `\\u${r.toString(16).padStart(4, "0")}` : i;
+		}
+		return `${t}"`;
+	}
+	return Array.isArray(e) ? `[${e.map(F).join(", ")}]` : typeof e == "object" ? `{${Object.keys(e).sort().map((t) => `${F(t)}: ${F(e[t])}`).join(", ")}}` : "null";
+}
+function I(e) {
+	let t = 0;
+	for (let n of e) {
+		let e = n && typeof n == "object" ? "text" in n ? n.text : "thinking" in n ? n.thinking : "" : "";
+		t += [...typeof e == "string" ? e : e === null ? "None" : String(e)].length;
+	}
+	return {
+		contentSha256: T(F(e)),
+		contentCharacters: t
+	};
+}
+var L = (e) => typeof e == "string" ? e : e == null ? "" : JSON.stringify(e), R = (e) => typeof e == "number" && Number.isFinite(e) ? e : void 0, z = [
+	[/await|wait_?for|wait_agent|^wait$|sleep|poll|watch_events|next_event/, "waiting"],
+	[/spawn|delegate|subagent|^task$|^agent$|send_message|post_message|coordinat|assign|settle|todowrite|^todo|cancel_child|children/, "coordination"],
+	[/^(write|edit|multiedit|notebookedit|str_replace|apply_patch|patch|create_file|write_file|edit_file|file_change|replace)/, "writing"],
+	[/web_?search|web_?fetch|^fetch$|search_papers|arxiv|scholar|knowledge|retriev|literature|crossref|^read|^view|^glob$|^grep$|^ls$|list_dir|open_file|^cat$|search_files|find_files/, "literature"],
+	[/verif|^check|_check|test|lean|prove|proof|validate|assert/, "verification"],
+	[/bash|shell|exec|command|^run|python|terminal|jupyter|interpreter|compute|^sh$/, "compute"]
+], B = [
+	[/\b(pip3? install|python3? -m pip install|npm (i|install|ci)\b|pnpm (i|install|add)\b|yarn add|apt(-get)? install|brew install|cargo install|uv (pip|add|sync)\b|conda install|git clone|elan |rustup )/, "setup"],
+	[/^\s*(sleep\b|while\b.*\bsleep\b|until\b)|\bwait\b\s*$/, "waiting"],
+	[/\b(pytest|unittest|cargo test|(npm|pnpm|yarn) (run )?test|lake (build|env)|lean\b|coqc|z3\b|verify|--check\b|sha256sum -c|diff -q)/, "verification"],
+	[/\b(curl|wget)\b[^|]*(arxiv|doi\.org|semanticscholar|scholar|crossref|openalex|https?:)/, "literature"],
+	[/^\s*(cat|head|tail|less|rg|grep|find|ls|wc|tree|file|stat|jq)\b|\bsed -n\b/, "literature"],
+	[/(^|[;&|]\s*)(cat\s*>|tee\b)|\bsed -i\b|>\s*\S+\.(md|tex|json|py|ts|mjs|txt)\b/, "writing"]
+];
+function V(e, t) {
+	let n = e.toLowerCase().replace(/^mcp__[^_]+(?:_[^_]+)*?__/, ""), r = /^mcp__([^_]+(?:[-_][^_]+)*?)__/.exec(e.toLowerCase())?.[1] ?? "", i = (() => {
+		if (typeof t == "string") try {
+			let e = JSON.parse(t);
+			return typeof e?.command == "string" ? e.command : typeof e?.cmd == "string" ? e.cmd : "";
+		} catch {
+			return "";
+		}
+		let e = t;
+		return typeof e?.command == "string" ? e.command : typeof e?.cmd == "string" ? e.cmd : "";
+	})(), a = "other";
+	for (let [e, t] of z) if (e.test(n)) {
+		a = t;
+		break;
+	}
+	if (a === "other" && /coordination/.test(r) && (a = "coordination"), (a === "compute" || a === "other") && i) {
+		for (let [e, t] of B) if (e.test(i)) return t;
+		return "compute";
+	}
+	return a;
+}
+function H(e, t) {
+	let n = [], r = 0, i = 1;
+	for (; r <= e.length;) {
+		let a = e.indexOf(10, r);
+		if (a < 0 && (a = e.length), !t || t(i)) {
+			let t = e.toString("utf8", r, a);
+			if (t.endsWith("\r") && (t = t.slice(0, -1)), t.trim()) {
+				let e;
+				try {
+					e = JSON.parse(t);
+				} catch {
+					e = void 0;
+				}
+				n.push({
+					line: i,
+					raw: t,
+					value: e
+				});
+			}
+		}
+		r = a + 1, i++;
+	}
+	return n;
+}
+var U = (e) => e ? (t) => e.some(([e, n]) => t >= e && t <= n) : void 0, W = (e) => {
+	try {
+		return f(e).sort();
+	} catch {
+		return [];
+	}
+};
+function G(e, t = "", n = []) {
+	for (let r of W(v(e, t))) {
+		let i = t ? `${t}/${r}` : r, a;
+		try {
+			a = m(v(e, i));
+		} catch {
+			continue;
+		}
+		a.isDirectory() ? G(e, i, n) : a.isFile() && n.push(i);
+	}
+	return n;
+}
+var K = (...e) => "/" + e.map((e) => String(e).replaceAll("~", "~0").replaceAll("/", "~1")).join("/");
+function q(e, t, n) {
+	for (; t > 0 && t < e.length && (e[t] & 192) == 128;) t++;
+	for (; n < e.length && n > 0 && (e[n] & 192) == 128;) n--;
+	return e.subarray(t, n).toString("utf8");
+}
+var J = class {
+	runDir;
+	nativeRoot;
+	maxText;
+	options;
+	runId;
+	runIdBasis;
+	manifestFiles = /* @__PURE__ */ new Map();
+	claimed = /* @__PURE__ */ new Map();
+	executionOf = /* @__PURE__ */ new Map();
+	sources = /* @__PURE__ */ new Map();
+	events = [];
+	gaps = [];
+	nodes = /* @__PURE__ */ new Map();
+	fileCache = /* @__PURE__ */ new Map();
+	nativeIndexCache;
+	rootId;
+	order = 0;
+	format = "other";
+	runInput = null;
+	runInputRel = null;
+	constructor(e, t, n, r = {}) {
+		this.runDir = e, this.nativeRoot = t, this.maxText = n, this.options = r;
+		let i = typeof r.manifest?.runId == "string" && r.manifest.runId ? r.manifest.runId : void 0;
+		this.runId = r.runId ?? i ?? g(e.replace(/\/+$/, "")), this.runIdBasis = r.runId ? "option" : i ? "manifest" : "directory", this.rootId = this.runId;
+		for (let e of r.manifest?.files ?? []) this.manifestFiles.set(e.path, e);
+	}
+	sourcePath(e) {
+		return !this.options.prefix || e.startsWith("native:") ? e : `${this.options.prefix}${e}`;
+	}
+	file(e, t = v(this.runDir, e)) {
+		let n = this.fileCache.get(t);
+		if (n) return n;
+		let r = this.options.files?.read(t), i = r?.bytes ?? u(t), a, o = {
+			bytes: i,
+			sha256: r?.sha256 ?? T(i),
+			get text() {
+				return a ??= i.toString("utf8");
+			}
+		}, s = this.manifestFiles.get(this.sourcePath(e));
+		if (s && E(s.sha256) !== o.sha256) throw new w(`${e} does not match its snapshot manifest`);
+		return this.fileCache.set(t, o), o;
+	}
+	digestOnly(e, t = v(this.runDir, e)) {
+		let n = this.manifestFiles.get(this.sourcePath(e));
+		if (n) return {
+			sha256: E(n.sha256),
+			bytes: n.bytes
+		};
+		if (this.options.files) try {
+			let e = this.options.files.read(t);
+			return {
+				sha256: e.sha256,
+				bytes: e.bytes.length
+			};
+		} catch {
+			return null;
+		}
+		let r;
+		try {
+			r = l(t, "r");
+		} catch {
+			return null;
+		}
+		try {
+			let e = i("sha256"), t = Buffer.allocUnsafe(1 << 20), n = 0;
+			for (let i = d(r, t); i > 0; i = d(r, t)) e.update(t.subarray(0, i)), n += i;
+			return {
+				sha256: e.digest("hex"),
+				bytes: n
+			};
+		} finally {
+			a(r);
+		}
+	}
+	addSource(e) {
+		let t = {
+			...e,
+			path: this.sourcePath(e.path)
+		}, n = `${t.path}\0${t.line ?? ""}\0${t.pointer ?? ""}`, r = this.sources.get(n);
+		return r?.sha256 ? r : (this.sources.set(n, t), t);
+	}
+	fileSource(e, t, n) {
+		let r = this.file(e, t);
+		return this.addSource({
+			path: e,
+			sha256: r.sha256,
+			bytes: r.bytes.length,
+			...n ? { label: n } : {}
+		});
+	}
+	listSource(e) {
+		let t = this.digestOnly(e);
+		t && this.addSource({
+			path: e,
+			...t
+		});
+	}
+	lineSource(e, t, n) {
+		let r = Buffer.from(n, "utf8");
+		return this.addSource({
+			path: e,
+			line: t,
+			sha256: T(r),
+			bytes: r.length
+		});
+	}
+	pointerSource(e, t, n, r) {
+		let i = Buffer.from(typeof n == "string" ? n : JSON.stringify(n), "utf8");
+		return this.addSource({
+			path: e,
+			pointer: t,
+			sha256: T(i),
+			bytes: i.length,
+			...r ? { label: r } : {}
+		});
+	}
+	clip(e, t) {
+		let n = Buffer.from(e, "utf8");
+		if (n.length <= this.maxText) return {
+			text: e,
+			clip: void 0
+		};
+		let r = Math.floor(this.maxText * .75), i = this.maxText - r, a = `${q(n, 0, r)}\n\n…\n\n${q(n, n.length - i, n.length)}`, o = t?.() ?? null;
+		return {
+			text: a,
+			clip: {
+				bytes: n.length,
+				sha256: o?.sha256 ?? null
+			}
+		};
+	}
+	compactValue(e, t = 0) {
+		if (typeof e == "string") {
+			let t = Math.min(this.maxText, 2048);
+			return Buffer.byteLength(e) > t ? this.clip(e, null).text.slice(0, t) + "…" : e;
+		}
+		if (Array.isArray(e)) {
+			let n = e.slice(0, 50).map((e) => this.compactValue(e, t + 1));
+			return e.length > 50 ? [...n, `… ${e.length - 50} more`] : n;
+		}
+		if (e && typeof e == "object") {
+			if (t > 6) return "…";
+			let n = {};
+			for (let [r, i] of Object.entries(e)) n[r] = this.compactValue(i, t + 1);
+			return n;
+		}
+		return e;
+	}
+	emit(e) {
+		let t = {
+			...e.source,
+			path: this.sourcePath(e.source.path)
+		};
+		this.events.push({
+			...e,
+			source: t,
+			id: n(t),
+			order: this.order++
+		});
+	}
+	claim(e, t, n) {
+		let r = this.claimed.get(e);
+		return r && r !== t ? (this.gaps.push({
+			nodeId: t,
+			code: "source-shared",
+			detail: `${this.sourcePath(n)} is already the conversation of ${r}`
+		}), !1) : (this.claimed.set(e, t), !0);
+	}
+	nodeFor(e) {
+		if (typeof e == "string") {
+			let t = e;
+			for (; t;) {
+				if (this.nodes.has(t)) return t;
+				let e = t.lastIndexOf(":s");
+				if (e <= 0) break;
+				t = t.slice(0, e);
+			}
+		}
+		return this.rootId;
+	}
+	addSandbox(e, t) {
+		e && typeof t == "string" && /^sandbox-/.test(t) && !e.sandboxes.includes(t) && e.sandboxes.push(t);
+	}
+	blob(e) {
+		let t = E(e);
+		if (!t) return null;
+		let n = `blobs/sha256-${t}.json`, r = v(this.runDir, n);
+		if (!s(r)) return null;
+		try {
+			return {
+				rel: n,
+				value: JSON.parse(this.file(n).text)
+			};
+		} catch {
+			return null;
+		}
+	}
+	readRunInput() {
+		let e = "run-input.json", t = v(this.runDir, e);
+		if (!s(t)) {
+			let n = /^(.*)\.v\d+$/.exec(this.runId), r = n ? v(_(this.runDir), n[1], "run-input.json") : null;
+			if (!r || !s(r)) return;
+			e = `../${n[1]}/run-input.json`, t = r;
+		}
+		try {
+			let n = this.file(e, t);
+			this.runInput = JSON.parse(n.text), this.runInputRel = e, this.fileSource(e, t);
+		} catch {
+			this.gaps.push({
+				nodeId: null,
+				code: "input-unreadable",
+				detail: `${e} is not valid JSON`
+			});
+			return;
+		}
+		let n = this.runInput?.placement?.childFiles;
+		Array.isArray(n) && n.forEach((t, n) => {
+			typeof t?.content == "string" && this.pointerSource(e, K("placement", "childFiles", n, "content"), t.content, L(t.path) || void 0);
+		});
+	}
+	readJournal() {
+		let e = "spawn-journal.jsonl", t = v(this.runDir, e);
+		if (!s(t)) return [];
+		let n = this.file(e);
+		this.fileSource(e);
+		let r = H(n.bytes), i = /* @__PURE__ */ new Map();
+		for (let e of r) {
+			let t = e.value?.event;
+			if (t?.kind !== "spawned" || typeof t.id != "string" || this.nodes.has(t.id)) continue;
+			let n = t.id, r = n.lastIndexOf(":s"), a = typeof t.parent == "string" ? t.parent : r > 0 ? n.slice(0, r) : null;
+			!a && this.nodes.size === 0 && (this.rootId = n);
+			let o = L(t.label) || (a ? "worker" : "root"), s = n.startsWith(this.rootId + ":") ? n.slice(this.rootId.length + 1) : n === this.rootId ? "" : n;
+			this.nodes.set(n, {
+				id: n,
+				label: s ? `${s}${t.key ? ` · ${t.key}` : ""}` : o,
+				parent: a,
+				kind: "agent",
+				role: o,
+				model: null,
+				servedModel: null,
+				harness: null,
+				start: P(t.at) ?? void 0,
+				sandboxes: [],
+				capture: {
+					channel: "journal",
+					status: "absent",
+					reason: null
+				},
+				taskDigest: t.identity?.taskDigest,
+				profileRef: t.profileRef,
+				outRefs: [],
+				transcriptRefs: [],
+				key: typeof t.key == "string" ? t.key : void 0
+			}), typeof t.runtime == "string" && i.set(n, t.runtime);
+		}
+		if (!this.nodes.size) return r;
+		for (let e of this.nodes.values()) e.parent && !this.nodes.has(e.parent) && (e.parent = null);
+		this.format = [...i.values()].includes("tangle-sandbox") ? "cloud" : "runtime";
+		let a = null, o = 0;
+		for (let t of r) {
+			let r = t.value?.event ?? t.value;
+			if (!r || typeof r != "object") continue;
+			let i = typeof r.id == "string" ? r.id : L(t.value?.root).split("/").at(-1), s = this.nodes.get(this.nodeFor(i)), c = typeof r.id == "string" ? this.nodes.get(r.id) : void 0, l = L(r.kind) || "unknown";
+			if (l === "materialized" && c) {
+				let e = r.receipt?.model;
+				e?.status === "known" && typeof e.id == "string" && !c.model && (c.model = e.id, c.modelSource = "materialization receipt"), r.receipt?.execution?.kind === "environment" && this.addSandbox(c, r.receipt.execution.id), r.receipt?.execution?.kind === "session" && typeof r.receipt.execution.id == "string" && this.executionOf.set(r.receipt.execution.id, {
+					node: c.id,
+					line: t.line
+				});
+			}
+			if (c) {
+				this.addSandbox(c, r.environmentId), this.addSandbox(c, r.request?.source?.environmentId);
+				for (let e of Array.isArray(r.kept) ? r.kept : []) this.addSandbox(c, e?.environmentId);
+			}
+			(l === "settled" || l === "reconciled") && c && ((l === "settled" || !c.status) && (c.status = L(r.status) || c.status, c.end = P(r.at) ?? c.end), l === "reconciled" && !c.end && (c.end = P(r.at) ?? void 0)), c && typeof r.outRef == "string" && !c.outRefs.includes(r.outRef) && c.outRefs.push(r.outRef);
+			let u = r.harnessTranscript;
+			c && u && (u.status === "available" && typeof u.transcriptRef == "string" ? (c.transcriptRefs.includes(u.transcriptRef) || c.transcriptRefs.push(u.transcriptRef), typeof u.harness == "string" && (c.harness ??= u.harness)) : typeof u.reason == "string" && (c.transcriptReason = u.reason));
+			let d = P(r.at ?? t.value?.at);
+			d && (a = d);
+			let f = d ?? a;
+			if (!f || !s) {
+				o++;
+				continue;
+			}
+			let { kind: p, id: m, seq: h, at: g, ..._ } = r, v = [l.replaceAll("-", " "), r.status ?? r.signal ?? r.record?.classification ?? r.admission?.phase].filter(Boolean).join(" · "), y = L(r.reason ?? r.cause ?? r.record?.error ?? r.outcome?.error ?? r.detail), b = y ? this.clip(y, () => this.lineSource(e, t.line, t.raw)) : null, x = r.spent ?? r.spend, S = l === "metered" && typeof x?.tokens?.input == "number" ? {
+				usage: {
+					input: x.tokens.input,
+					...typeof x.tokens.output == "number" ? { output: x.tokens.output } : {}
+				},
+				usageScope: "metered"
+			} : void 0;
+			this.emit({
+				node: s.id,
+				at: f,
+				kind: l,
+				category: "lifecycle",
+				label: v,
+				source: {
+					path: e,
+					sha256: n.sha256,
+					line: t.line
+				},
+				detail: {
+					lifecycle: l,
+					...i && i !== s.id ? { subject: i } : {},
+					...d ? {} : { atBasis: "carried" },
+					...b ? {
+						publicText: b.text,
+						...b.clip ? { clip: b.clip } : {}
+					} : {},
+					...l === "settled" || l === "execution-result" ? { isError: r.status === "down" || r.outcome?.success === !1 } : {},
+					...x && (l === "settled" || l === "metered" || l === "reconciled") ? { spent: this.compactValue(x) } : {},
+					...S ?? {},
+					data: this.compactValue(_)
+				}
+			});
+		}
+		return o && this.gaps.push({
+			nodeId: null,
+			code: "journal-untimed-lines",
+			detail: `${o} spawn-journal lines carry no time and precede every timed line`
+		}), r;
+	}
+	resultJson() {
+		let e = v(this.runDir, "result.json");
+		if (!s(e)) return null;
+		try {
+			let e = JSON.parse(this.file("result.json").text);
+			return this.fileSource("result.json"), e;
+		} catch {
+			return null;
+		}
+	}
+	nativeFiles(e) {
+		let t = /* @__PURE__ */ new Map(), n = 0, r = !1, i = (e, r, i, a, o) => {
+			let s;
+			try {
+				s = m(i).size;
+			} catch {
+				return;
+			}
+			let c = t.get(e);
+			(!c || s > c.bytes) && t.set(e, {
+				rel: r,
+				abs: i,
+				hex: a,
+				sessionId: o,
+				bytes: s,
+				order: c?.order ?? n++
+			});
+		}, a = (e) => this.nativeCacheDir(e);
+		for (let t of e.transcriptRefs) {
+			let n = this.blob(t);
+			if (n?.value?.kind !== "retained-harness-transcript") continue;
+			let o = n.value;
+			this.fileSource(n.rel);
+			let c = E(o.snapshot?.archive?.sha256 ?? o.snapshot?.archive?.locator?.digest), l = typeof o.source?.nativeSessionId == "string" ? o.source.nativeSessionId : null;
+			e.nativeSessionId ??= l ?? void 0, typeof o.harness == "string" && (e.harness ??= o.harness), this.addSandbox(e, o.source?.environmentId);
+			let u = (Array.isArray(o.files) ? o.files : []).filter((e) => typeof e?.path == "string" && D.test(e.path)).filter((e) => !l || e.path.endsWith(`/${l}.jsonl`));
+			if (!c || !u.length) continue;
+			let d = a(c);
+			if (!d) {
+				r = !0;
+				continue;
+			}
+			for (let t of u) {
+				let n = t.path.split("/"), r = [t.path, [
+					"workspace/__retention__/sessions",
+					n[0],
+					"native",
+					...n.slice(1)
+				].join("/")].find((e) => s(v(d, e)));
+				if (!r) {
+					this.gaps.push({
+						nodeId: e.id,
+						code: "no-transcript:native-file-missing",
+						detail: `${t.path} is not in archive ${c}`
+					});
+					continue;
+				}
+				let a = v(d, r), o = `native:${c}/${r}`, u = this.file(o, a), f = E(t.sha256);
+				if (f && f !== u.sha256) {
+					this.gaps.push({
+						nodeId: e.id,
+						code: "no-transcript:native-sha256-mismatch",
+						detail: `${o} does not match its manifest`
+					});
+					continue;
+				}
+				i(O(t.path), o, a, c, l);
+			}
+		}
+		let o = this.nativeIndex().get(e.id);
+		if (o) {
+			let t = E(o.snapshot?.archive);
+			this.addSandbox(e, o.environmentId), typeof o.harness == "string" && (e.harness ??= o.harness);
+			let n = t ? a(t) : void 0;
+			t && !n && (r = !0);
+			for (let e of n && Array.isArray(o.native?.sessions) ? o.native.sessions : []) {
+				let r = typeof e?.path == "string" ? O(e.path) : null;
+				if (!r || typeof e.sandboxSessionId != "string" || typeof e.rootScope != "string") continue;
+				let a = [
+					"workspace/__retention__/sessions",
+					e.sandboxSessionId,
+					"native",
+					...typeof e.sourceId == "string" ? [e.sourceId] : [],
+					e.rootScope,
+					e.path
+				].join("/");
+				i(r, `native:${t}/${a}`, v(n, a), t, null);
+			}
+		}
+		if (t.size) {
+			let e = [...t.values()].sort((e, t) => e.order - t.order);
+			for (let t of e) this.fileSource(t.rel, t.abs);
+			return e;
+		}
+		return r ? "not-cached" : null;
+	}
+	nativeCacheDir(e) {
+		return this.nativeRoot ? [
+			e,
+			`sha256-${e}`,
+			`sha256:${e}`
+		].map((e) => v(this.nativeRoot, e)).find((e) => s(e)) : void 0;
+	}
+	nativeStore(e) {
+		let t = this.nativeIndex().get(e.id), n = E(t?.snapshot?.archive), r = n ? this.nativeCacheDir(n) : void 0, i = (Array.isArray(t?.native?.sessions) ? t.native.sessions : []).filter((e) => typeof e?.path == "string" && k.test(e.path) && typeof e.sandboxSessionId == "string" && typeof e.rootScope == "string");
+		if (!r || !i.length) return null;
+		let a = (e) => [
+			"workspace/__retention__/sessions",
+			e.sandboxSessionId,
+			"native",
+			...typeof e.sourceId == "string" ? [e.sourceId] : [],
+			e.rootScope,
+			e.path
+		].join("/"), o = a(i[0]), c = v(r, o);
+		if (!s(c)) return this.gaps.push({
+			nodeId: e.id,
+			code: "no-transcript:native-file-missing",
+			detail: `${o} is not in archive ${n}`
+		}), null;
+		let l = i.filter((e) => a(e) === o && !e.parentNativeSessionId && typeof e.nativeSessionId == "string").map((e) => e.nativeSessionId);
+		return {
+			rel: `native:${n}/${o}`,
+			abs: c,
+			sessionIds: l
+		};
+	}
+	nativeIndex() {
+		if (this.nativeIndexCache) return this.nativeIndexCache;
+		let e = /* @__PURE__ */ new Map(), t = v(this.runDir, A);
+		if (s(t)) {
+			this.listSource(A);
+			for (let n of H(this.options.files?.read(t).bytes ?? u(t))) {
+				let t = n.value;
+				if (t?.schema !== "disco.native-capture.v1" || typeof t.nodeId != "string") continue;
+				let r = e.get(t.nodeId);
+				(!r || String(t.at) >= String(r.at)) && e.set(t.nodeId, t);
+			}
+		}
+		return this.nativeIndexCache = e;
+	}
+	readNative(e, t) {
+		let n = !1;
+		for (let r of t) {
+			let t = this.readClaudeSession(e, r.rel, r.abs);
+			t !== null && (n ||= t.unparsable > 0);
+		}
+		e.capture = {
+			channel: "native",
+			status: n ? "lossy" : "complete",
+			reason: n ? "unparsable-lines" : null
+		}, e.harness === null && (e.harness = "claude-code");
+	}
+	readClaudeSession(e, t, n, r) {
+		let i = this.file(t, n);
+		if (!this.claim(i.sha256, e.id, t)) return null;
+		this.fileSource(t, n);
+		let a = {
+			events: 0,
+			unparsable: 0,
+			untimed: 0
+		}, o = /* @__PURE__ */ new Set(), s, c = e.start ?? null;
+		for (let n of H(i.bytes, U(r))) {
+			let r = n.value;
+			if (!r) {
+				a.unparsable++;
+				continue;
+			}
+			let l = P(r.timestamp) ?? c;
+			if (!l) {
+				a.untimed++;
+				continue;
+			}
+			c = l;
+			let u = {
+				path: t,
+				sha256: i.sha256,
+				line: n.line
+			}, d = () => this.lineSource(t, n.line, n.raw), f = typeof r.uuid == "string" ? { nativeRecordId: r.uuid } : {}, p = r.isSidechain ? { sidechain: !0 } : {}, m = r.message, h = this.events.length;
+			if (r.type === "assistant" && m) {
+				let t = Array.isArray(m.content) ? m.content : [{
+					type: "text",
+					text: L(m.content)
+				}], n = t.filter((e) => e?.type === "text").map((e) => L(e.text)).join("\n\n"), i = t.filter((e) => e?.type === "thinking").map((e) => L(e.thinking)).filter(Boolean).join("\n\n"), a = t.filter((e) => e?.type === "thinking" && !L(e.thinking)).length, c = t.filter((e) => e?.type === "redacted_thinking").length, h = t.filter((e) => e?.type === "tool_use" || e?.type === "server_tool_use"), g = m.usage, _ = typeof m.id != "string" || !o.has(m.id);
+				typeof m.id == "string" && o.add(m.id), typeof m.model == "string" && m.model !== "<synthetic>" && (e.servedModel = m.model, e.modelSource = "native response");
+				let v = n ? this.clip(n, d) : null, y = i ? this.clip(i, d) : null;
+				this.emit({
+					node: e.id,
+					at: l,
+					kind: "message",
+					category: h.length ? V(L(h[0].name), h[0].input) : "reasoning",
+					label: h.length ? `assistant · ${h.map((e) => L(e.name)).join(", ")}` : "assistant",
+					source: u,
+					detail: {
+						role: "assistant",
+						...f,
+						...v ? { publicText: v.text } : {},
+						...y ? { reasoning: y.text } : {},
+						...a ? { reasoningOmitted: a } : {},
+						...c ? { reasoningRedacted: c } : {},
+						...v?.clip ?? y?.clip ? { clip: v?.clip ?? y?.clip } : {},
+						...h.length ? { publicToolCalls: h.map((e) => {
+							let t = this.clip(JSON.stringify(e.input ?? {}), d);
+							return {
+								id: L(e.id),
+								name: L(e.name),
+								input: t.text,
+								...t.clip ? { clip: t.clip } : {}
+							};
+						}) } : {},
+						...g && _ ? { usage: {
+							input: R(g.input_tokens),
+							output: R(g.output_tokens),
+							cacheRead: R(g.cache_read_input_tokens),
+							cacheWrite: R(g.cache_creation_input_tokens)
+						} } : {},
+						...typeof m.model == "string" ? { responseReportedModel: m.model } : {},
+						...r.isApiErrorMessage ? { responseStatus: "error" } : {},
+						...p
+					}
+				}), s = this.events.at(-1);
+			} else if (r.type === "user" && m && typeof m.content == "string") {
+				let t = this.clip(m.content, d);
+				this.emit({
+					node: e.id,
+					at: l,
+					kind: "message",
+					category: "other",
+					label: "user",
+					source: u,
+					detail: {
+						role: "user",
+						...f,
+						publicText: t.text,
+						...t.clip ? { clip: t.clip } : {},
+						...p
+					}
+				});
+			} else if (r.type === "user" && m) {
+				let t = Array.isArray(m.content) ? m.content : [], n = [];
+				t.forEach((e, t) => {
+					e?.type === "tool_result" && n.push({
+						index: t,
+						block: e
+					});
+				});
+				let r = t.findIndex((e) => e?.type === "text" || e?.type === "image"), i = t.filter((e) => e?.type === "text" || e?.type === "image").map((e) => e.type === "image" ? "[image]" : L(e.text)).join("\n\n");
+				i && n.push({
+					index: r,
+					text: i
+				}), n.sort((e, t) => e.index - t.index);
+				let a = n.length > 1;
+				for (let t of n) {
+					let n = a ? {
+						...u,
+						item: t.index
+					} : u;
+					if (t.block) {
+						let r = t.block, i = typeof r.content == "string" ? r.content : Array.isArray(r.content) ? r.content.map((e) => e?.type === "text" ? L(e.text) : e?.type === "image" ? "[image]" : JSON.stringify(e)).join("\n") : L(r.content), a = this.clip(i, d);
+						this.emit({
+							node: e.id,
+							at: l,
+							kind: "tool-result",
+							category: "other",
+							label: "tool result",
+							source: n,
+							detail: {
+								role: "toolResult",
+								...f,
+								toolCallId: L(r.tool_use_id),
+								isError: r.is_error === !0,
+								publicText: a.text,
+								...a.clip ? { clip: a.clip } : {},
+								...p
+							}
+						});
+					} else {
+						let r = this.clip(t.text, d);
+						this.emit({
+							node: e.id,
+							at: l,
+							kind: "message",
+							category: "other",
+							label: "user",
+							source: n,
+							detail: {
+								role: "user",
+								...f,
+								publicText: r.text,
+								...r.clip ? { clip: r.clip } : {},
+								...p
+							}
+						});
+					}
+				}
+			}
+			r.type === "cost-state" && s && R(r.totalCostUSD) !== void 0 && (s.detail.costListUsd = r.totalCostUSD, s.detail.usdKnown = !1, s.detail.costScope = "session-total"), this.events.length === h && this.emitRecord(e, l, u, r, f), a.events += this.events.length - h;
+		}
+		return a.untimed && this.gaps.push({
+			nodeId: e.id,
+			code: "untimed-lines",
+			detail: `${a.untimed} lines of ${this.sourcePath(t)} carry no time`
+		}), a.unparsable && this.gaps.push({
+			nodeId: e.id,
+			code: "unparsable-lines",
+			detail: `${a.unparsable} lines of ${this.sourcePath(t)} are not JSON`
+		}), a;
+	}
+	emitRecord(e, t, n, r, i = {}) {
+		let a = L(r?.type) || "unknown", o = L(r?.subtype ?? r?.customType ?? r?.payload?.type), { type: s, timestamp: c, message: l, ...u } = r ?? {};
+		this.emit({
+			node: e.id,
+			at: t,
+			kind: "record",
+			category: a === "system" || a === "session" || a.endsWith("_change") ? "lifecycle" : "other",
+			label: [a.replaceAll("_", " "), o.replaceAll("_", " ")].filter(Boolean).join(" · "),
+			source: n,
+			detail: {
+				recordType: a,
+				...o ? { recordSubtype: o } : {},
+				...i,
+				data: this.compactValue(r?.message ? {
+					...u,
+					message: r.message
+				} : u)
+			}
+		});
+	}
+	readLiveStream(e) {
+		let t = `${j}/${encodeURIComponent(e.id)}`, n = G(v(this.runDir, t)).filter((e) => e.endsWith(".jsonl")), r = 0;
+		for (let i of n) {
+			let n = `${t}/${i}`, a = this.file(n);
+			if (!this.claim(a.sha256, e.id, n)) continue;
+			this.fileSource(n);
+			let o = H(a.bytes).filter((e) => e.value && typeof e.value == "object");
+			r += this.readPartEvents(e, n, a, o.map((e) => e.value), {
+				where: (e) => ({ line: o[e].line }),
+				full: (e) => this.lineSource(n, o[e].line, o[e].raw)
+			});
+		}
+		return r ? (e.capture = {
+			channel: "live",
+			status: "lossy",
+			reason: "live-stream-until-settled"
+		}, !0) : !1;
+	}
+	readOpenCode(e, t = "native-trajectory.json") {
+		let n, r;
+		try {
+			r = this.file(t), n = JSON.parse(r.text);
+		} catch {
+			return !1;
+		}
+		return !Array.isArray(n?.messages) || !Array.isArray(n?.parts) || !this.claim(r.sha256, e.id, t) ? !1 : (this.fileSource(t), this.projectOpenCode(e, n, t, r.sha256, (e, t) => K("parts", t, "data")), !0);
+	}
+	readOpenCodeStore(e, t) {
+		let n = this.file(t.rel, t.abs);
+		if (!t.sessionIds.length || !this.claim(n.sha256, e.id, t.rel)) return !1;
+		let r = process.getBuiltinModule?.("node:sqlite");
+		if (!r) return this.gaps.push({
+			nodeId: e.id,
+			code: "no-transcript:opencode-store-unreadable",
+			detail: "this Node has no node:sqlite"
+		}), !1;
+		let i = c(v(h(), "agent-record-opencode-")), a;
+		try {
+			for (let e of [
+				"",
+				"-wal",
+				"-shm"
+			]) s(t.abs + e) && o(t.abs + e, v(i, `opencode.db${e}`));
+			let e = new r.DatabaseSync(v(i, "opencode.db"), { readOnly: !0 });
+			try {
+				let n = JSON.stringify(t.sessionIds), r = "session_id IN (SELECT value FROM json_each(?))";
+				a = {
+					session: e.prepare("SELECT * FROM session WHERE id IN (SELECT value FROM json_each(?)) ORDER BY time_created, id").all(n),
+					messages: e.prepare(`SELECT id, session_id, time_created, data FROM message WHERE ${r} ORDER BY time_created, id`).all(n),
+					parts: e.prepare(`SELECT id, message_id, session_id, time_created, data FROM part WHERE ${r} ORDER BY time_created, id`).all(n)
+				};
+			} finally {
+				e.close();
+			}
+		} catch (n) {
+			return this.gaps.push({
+				nodeId: e.id,
+				code: "no-transcript:opencode-store-unreadable",
+				detail: `${this.sourcePath(t.rel)}: ${String(n?.message ?? n).slice(0, 200)}`
+			}), !1;
+		} finally {
+			p(i, {
+				recursive: !0,
+				force: !0
+			});
+		}
+		return this.fileSource(t.rel, t.abs), this.projectOpenCode(e, a, t.rel, n.sha256, (e) => K("part", L(e.id), "data")), !0;
+	}
+	projectOpenCode(e, t, n, r, i) {
+		let a = Array.isArray(t.session) ? t.session[0] : t.session;
+		if (a?.model) try {
+			let t = typeof a.model == "string" ? JSON.parse(a.model) : a.model;
+			typeof t?.id == "string" && (e.model ??= [t.providerID, t.id].filter(Boolean).join("/"));
+		} catch {}
+		typeof a?.id == "string" && (e.nativeSessionId ??= a.id), e.harness ??= "opencode";
+		let o = /* @__PURE__ */ new Map();
+		t.messages.forEach((e) => {
+			try {
+				o.set(e.id, typeof e.data == "string" ? JSON.parse(e.data) : e.data);
+			} catch {
+				o.set(e.id, {});
+			}
+		});
+		let s = t.parts.map((e, t) => ({
+			part: e,
+			index: t
+		})).sort((e, t) => (e.part.time_created ?? 0) - (t.part.time_created ?? 0) || e.index - t.index), c = /* @__PURE__ */ new Map(), l = 0, u = 0;
+		for (let { part: t, index: a } of s) {
+			let s;
+			try {
+				s = typeof t.data == "string" ? JSON.parse(t.data) : t.data;
+			} catch {
+				l++;
+				continue;
+			}
+			let d = o.get(t.message_id) ?? {}, f = d.role === "user" ? "user" : "assistant", p = i(t, a), m = {
+				path: n,
+				sha256: r,
+				pointer: p
+			}, h = () => this.pointerSource(n, p, t.data), g = P(s?.time?.start ?? t.time_created) ?? e.start;
+			if (!g) {
+				u++;
+				continue;
+			}
+			let _ = typeof t.id == "string" ? { nativeRecordId: t.id } : {};
+			if (f === "assistant" && typeof d.modelID == "string" && (e.servedModel = [d.providerID, d.modelID].filter(Boolean).join("/")), (s?.type === "text" || s?.type === "reasoning") && (L(s.text) || s.type === "text")) {
+				let n = this.clip(L(s.text), h);
+				this.emit({
+					node: e.id,
+					at: g,
+					kind: "message",
+					category: f === "user" ? "other" : "reasoning",
+					label: f,
+					source: m,
+					detail: {
+						role: f,
+						..._,
+						...s.type === "text" ? { publicText: n.text } : { reasoning: n.text },
+						...n.clip ? { clip: n.clip } : {},
+						...s.synthetic ? { synthetic: !0 } : {}
+					}
+				}), c.set(t.message_id, this.events.at(-1));
+			} else if (s?.type === "tool") {
+				let n = s.state ?? {}, r = this.clip(JSON.stringify(n.input ?? {}), h), i = P(n.time?.start) ?? g, a = P(n.time?.end), o = V(L(s.tool), n.input), l = n.status === "completed" || n.status === "error";
+				if (this.emit({
+					node: e.id,
+					at: i,
+					kind: "message",
+					category: o,
+					label: `assistant · ${L(s.tool)}`,
+					source: l ? {
+						...m,
+						item: 0
+					} : m,
+					detail: {
+						role: "assistant",
+						..._,
+						publicToolCalls: [{
+							id: L(s.callID || t.id),
+							name: L(s.tool),
+							input: r.text,
+							...r.clip ? { clip: r.clip } : {}
+						}]
+					}
+				}), c.set(t.message_id, this.events.at(-1)), l) {
+					let r = n.status === "error" ? L(n.error) : L(n.output), c = this.clip(r, h);
+					this.emit({
+						node: e.id,
+						at: a ?? i,
+						kind: "tool-result",
+						category: o,
+						label: `tool result · ${L(s.tool)}`,
+						source: {
+							...m,
+							item: 1
+						},
+						detail: {
+							role: "toolResult",
+							..._,
+							toolCallId: L(s.callID || t.id),
+							isError: n.status === "error",
+							publicText: c.text,
+							...c.clip ? { clip: c.clip } : {},
+							...a && n.time?.start ? { durationMs: Math.max(0, Number(n.time.end) - Number(n.time.start)) } : {}
+						}
+					});
+				}
+			} else {
+				if (s?.type === "step-finish") {
+					let e = c.get(t.message_id), n = s.tokens;
+					e && n && (e.detail.usage = {
+						input: R(n.input),
+						output: R(n.output),
+						cacheRead: R(n.cache?.read),
+						cacheWrite: R(n.cache?.write),
+						...R(n.reasoning) === void 0 ? {} : { reasoning: n.reasoning }
+					}, R(s.cost) !== void 0 && s.cost > 0 && (e.detail.costListUsd = s.cost, e.detail.usdKnown = !1));
+				}
+				this.emitRecord(e, g, m, {
+					...s,
+					type: L(s?.type) || "part"
+				}, _);
+			}
+		}
+		return u && this.gaps.push({
+			nodeId: e.id,
+			code: "untimed-lines",
+			detail: `${u} parts of ${this.sourcePath(n)} carry no time`
+		}), e.capture = {
+			channel: "oc",
+			status: l ? "lossy" : "complete",
+			reason: l ? "unparsable-parts" : null
+		}, !0;
+	}
+	piSessions() {
+		let e = v(this.runDir, "trace/pi-sessions");
+		return s(e) ? G(e).filter((e) => e.endsWith(".jsonl")).map((e) => {
+			let t = `trace/pi-sessions/${e}`, n = this.file(t), r = H(n.bytes), i = r.find((e) => e.value?.type === "session")?.value, a = r.find((e) => e.value?.type === "message" && e.value.message?.role === "user")?.value?.message, o = a ? typeof a.content == "string" ? a.content : Array.isArray(a.content) ? a.content.filter((e) => e?.type === "text").map((e) => L(e.text)).join("") : null : null;
+			return {
+				rel: t,
+				sessionId: L(i?.id) || g(e, ".jsonl"),
+				digest: o === null ? null : `sha256:${T(JSON.stringify(o))}`,
+				rows: r,
+				sha256: n.sha256
+			};
+		}) : [];
+	}
+	readPi(e, t) {
+		e.harness ??= "pi";
+		let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+		for (let i of t) {
+			if (!this.claim(i.sha256, e.id, i.rel)) continue;
+			this.fileSource(i.rel), e.nativeSessionId ??= i.sessionId;
+			let t = 0, a = null;
+			for (let o of i.rows) {
+				let s = o.value;
+				if (!s) continue;
+				let c = P(s.timestamp) ?? a;
+				if (!c) {
+					t++;
+					continue;
+				}
+				a = c;
+				let l = {
+					path: i.rel,
+					sha256: i.sha256,
+					line: o.line
+				}, u = typeof s.id == "string" ? { nativeRecordId: s.id } : {};
+				if (s.type === "model_change" && typeof s.modelId == "string" && (e.model ??= s.modelId), s.type !== "message") {
+					this.emitRecord(e, c, l, s, u);
+					continue;
+				}
+				let d = s.message ?? {}, f = () => this.lineSource(i.rel, o.line, o.raw), p = Array.isArray(d.content) ? d.content : [{
+					type: "text",
+					text: L(d.content)
+				}], m = p.filter((e) => e?.type === "text").map((e) => L(e.text)).join("\n\n"), h = {
+					...typeof s.parentId == "string" ? { nativeParentId: s.parentId } : {},
+					...I(Array.isArray(d.content) ? d.content : [{
+						type: "text",
+						text: d.content
+					}])
+				};
+				if (d.role === "toolResult") {
+					let t = this.clip(m, f);
+					typeof d.toolCallId == "string" && r.add(d.toolCallId), this.emit({
+						node: e.id,
+						at: c,
+						kind: "tool-result",
+						category: "other",
+						label: `tool result · ${L(d.toolName)}`,
+						source: l,
+						detail: {
+							role: "toolResult",
+							...u,
+							...h,
+							toolCallId: L(d.toolCallId),
+							isError: d.isError === !0,
+							publicText: t.text,
+							...t.clip ? { clip: t.clip } : {}
+						}
+					});
+					continue;
+				}
+				let g = p.filter((e) => e?.type === "thinking").map((e) => L(e.thinking)).filter(Boolean).join("\n\n"), _ = p.filter((e) => e?.type === "toolCall" || e?.type === "tool_use");
+				for (let e of _) typeof e.id == "string" && n.add(e.id);
+				typeof d.model == "string" && d.stopReason !== "error" && (e.servedModel = d.model);
+				let v = d.role === "assistant" ? {
+					...typeof d.model == "string" ? { responseReportedModel: d.model } : {},
+					...typeof d.stopReason == "string" ? { responseStatus: d.stopReason } : {},
+					...typeof d.responseId == "string" ? { responseId: d.responseId } : {}
+				} : {}, y = m ? this.clip(m, f) : null, b = g ? this.clip(g, f) : null, x = d.usage;
+				this.emit({
+					node: e.id,
+					at: c,
+					kind: "message",
+					category: _.length ? V(L(_[0].name), _[0].arguments ?? _[0].input) : d.role === "user" ? "other" : "reasoning",
+					label: d.stopReason === "error" ? "failed assistant request" : _.length ? `${L(d.role)} · ${_.map((e) => L(e.name)).join(", ")}` : L(d.role),
+					source: l,
+					detail: {
+						role: L(d.role),
+						...u,
+						...h,
+						...v,
+						...y ? { publicText: y.text } : {},
+						...b ? { reasoning: b.text } : {},
+						...y?.clip ?? b?.clip ? { clip: y?.clip ?? b?.clip } : {},
+						..._.length ? { publicToolCalls: _.map((e) => {
+							let t = this.clip(JSON.stringify(e.arguments ?? e.input ?? {}), f);
+							return {
+								id: L(e.id),
+								name: L(e.name),
+								input: t.text,
+								...t.clip ? { clip: t.clip } : {}
+							};
+						}) } : {},
+						...x && d.stopReason !== "error" ? { usage: {
+							input: R(x.input),
+							output: R(x.output),
+							cacheRead: R(x.cacheRead),
+							cacheWrite: R(x.cacheWrite)
+						} } : {},
+						...R(x?.cost?.total) !== void 0 && x.cost.total > 0 ? {
+							costListUsd: x.cost.total,
+							usdKnown: !1
+						} : {}
+					}
+				});
+			}
+			t && this.gaps.push({
+				nodeId: e.id,
+				code: "untimed-lines",
+				detail: `${t} lines of ${this.sourcePath(i.rel)} carry no time`
+			});
+		}
+		let i = [...n].filter((e) => !r.has(e)).length;
+		i && this.gaps.push({
+			nodeId: e.id,
+			code: "tool-results-not-retained",
+			detail: `${i} tool calls have no result in the session`
+		}), e.capture = {
+			channel: "pi",
+			status: i ? "lossy" : "complete",
+			reason: i ? "tool-results-not-retained" : null
+		};
+	}
+	bridgeStreams() {
+		let e = v(this.runDir, "trace/bridge-sessions");
+		return s(e) ? G(e).filter((e) => e.endsWith(".jsonl")).map((e) => {
+			let t = `trace/bridge-sessions/${e}`, n = this.file(t), r = H(n.bytes), i = r.find((e) => e.value?.table === "sessions");
+			return {
+				rel: t,
+				rows: r,
+				sha256: n.sha256,
+				sessionId: L(i?.value?.row?.external_id) || null,
+				sessionLine: i?.line ?? null
+			};
+		}) : [];
+	}
+	readBridgeStream(e, t) {
+		if (!this.claim(t.sha256, e.id, t.rel)) return !1;
+		this.fileSource(t.rel);
+		let n = 0;
+		for (let r of t.rows) {
+			let i = r.value;
+			if (!i || typeof i.table != "string") continue;
+			let a = i.row ?? {}, o = P(a.occurred_at) ?? P(a.received_at) ?? P(Number(a.created_at)) ?? P(Number(a.updated_at));
+			if (!o) {
+				n++;
+				continue;
+			}
+			let s = {
+				path: t.rel,
+				sha256: t.sha256,
+				line: r.line
+			}, c = () => this.lineSource(t.rel, r.line, r.raw);
+			if (i.table !== "retained_events") {
+				this.emitRecord(e, o, s, {
+					type: `bridge ${i.table.replaceAll("_", " ")}`,
+					...a
+				});
+				continue;
+			}
+			let l;
+			try {
+				l = JSON.parse(L(a.event_json));
+			} catch {
+				l = null;
+			}
+			let u = l?.event ?? {}, d = typeof a.event_id == "string" ? { nativeRecordId: a.event_id } : {};
+			if (typeof u.content == "string" && u.content) {
+				let t = this.clip(u.content, c);
+				this.emit({
+					node: e.id,
+					at: o,
+					kind: "message",
+					category: "reasoning",
+					label: "assistant",
+					source: s,
+					detail: {
+						role: "assistant",
+						...d,
+						publicText: t.text,
+						...t.clip ? { clip: t.clip } : {}
+					}
+				});
+			} else if (Array.isArray(u.tool_calls) && u.tool_calls.length) {
+				let t = u.tool_calls.length > 1;
+				u.tool_calls.forEach((n, r) => {
+					let i = this.clip(typeof n?.arguments == "string" ? n.arguments : JSON.stringify(n?.arguments ?? {}), c);
+					this.emit({
+						node: e.id,
+						at: o,
+						kind: "message",
+						category: V(L(n?.name), n?.arguments),
+						label: `assistant · ${L(n?.name)}`,
+						source: t ? {
+							...s,
+							item: r
+						} : s,
+						detail: {
+							role: "assistant",
+							...d,
+							publicToolCalls: [{
+								id: L(n?.id),
+								name: L(n?.name),
+								input: i.text,
+								...i.clip ? { clip: i.clip } : {}
+							}]
+						}
+					});
+				});
+			} else {
+				let t = Object.keys(u)[0] ?? L(l?.type) ?? "event";
+				this.emitRecord(e, o, s, {
+					type: `bridge ${t.replaceAll("_", " ")}`,
+					...u
+				}, {
+					...d,
+					...u.error ? { isError: !0 } : {}
+				});
+			}
+		}
+		return n && this.gaps.push({
+			nodeId: e.id,
+			code: "untimed-lines",
+			detail: `${n} rows of ${this.sourcePath(t.rel)} carry no time`
+		}), e.harness ??= "opencode", e.capture = {
+			channel: "bridge",
+			status: "lossy",
+			reason: "bridge-stream-without-prompts-or-results"
+		}, !0;
+	}
+	readCodex(e, t, n) {
+		let r = this.file(t);
+		if (!this.claim(r.sha256, e.id, t)) return null;
+		this.fileSource(t), e.harness ??= "codex";
+		let i = {
+			unparsable: 0,
+			untimed: 0
+		};
+		for (let a of H(r.bytes, U(n))) {
+			let n = a.value;
+			if (!n) {
+				i.unparsable++;
+				continue;
+			}
+			let o = P(n.timestamp);
+			if (!o) {
+				i.untimed++;
+				continue;
+			}
+			let s = {
+				path: t,
+				sha256: r.sha256,
+				line: a.line
+			}, c = () => this.lineSource(t, a.line, a.raw), l = n.payload ?? {};
+			if (n.type === "session_meta" && typeof l.id == "string" && (e.nativeSessionId ??= l.id), n.type === "turn_context" && typeof l.model == "string" && (e.model ??= l.model, e.servedModel = l.model, e.modelSource ??= "codex turn context"), n.type === "response_item" && l.type === "message") {
+				let t = L(l.role) || "assistant", n = (Array.isArray(l.content) ? l.content : []).map((e) => e?.type === "input_image" ? "[image]" : L(e?.text)).filter(Boolean).join("\n\n"), r = this.clip(n, c);
+				this.emit({
+					node: e.id,
+					at: o,
+					kind: "message",
+					category: t === "assistant" ? "reasoning" : "other",
+					label: t,
+					source: s,
+					detail: {
+						role: t,
+						publicText: r.text,
+						...r.clip ? { clip: r.clip } : {}
+					}
+				});
+				continue;
+			}
+			if (n.type === "response_item" && l.type === "reasoning") {
+				let t = (Array.isArray(l.summary) ? l.summary : []).map((e) => L(e?.text)).filter(Boolean).join("\n\n"), n = t ? this.clip(t, c) : null;
+				this.emit({
+					node: e.id,
+					at: o,
+					kind: "message",
+					category: "reasoning",
+					label: "reasoning",
+					source: s,
+					detail: {
+						role: "assistant",
+						...n ? {
+							reasoning: n.text,
+							...n.clip ? { clip: n.clip } : {}
+						} : { contentOmitted: "encrypted reasoning" }
+					}
+				});
+				continue;
+			}
+			let u = n.type === "response_item" && (l.type === "function_call" || l.type === "custom_tool_call" || l.type === "local_shell_call" || l.type === "web_search_call") ? {
+				id: L(l.call_id ?? l.id),
+				name: l.type === "local_shell_call" ? "shell" : l.type === "web_search_call" ? "web_search" : L(l.name),
+				input: l.type === "function_call" ? L(l.arguments) : l.type === "custom_tool_call" ? L(l.input) : JSON.stringify(l.action ?? {})
+			} : null;
+			if (u) {
+				let t = this.clip(u.input, c);
+				this.emit({
+					node: e.id,
+					at: o,
+					kind: "message",
+					category: V(u.name, u.input),
+					label: `assistant · ${u.name}`,
+					source: s,
+					detail: {
+						role: "assistant",
+						publicToolCalls: [{
+							id: u.id,
+							name: u.name,
+							input: t.text,
+							...t.clip ? { clip: t.clip } : {}
+						}]
+					}
+				});
+				continue;
+			}
+			if (n.type === "response_item" && (l.type === "function_call_output" || l.type === "custom_tool_call_output")) {
+				let t = l.output, n = typeof t == "string" ? t : typeof t?.content == "string" ? t.content : JSON.stringify(t ?? null), r = this.clip(n, c);
+				this.emit({
+					node: e.id,
+					at: o,
+					kind: "tool-result",
+					category: "other",
+					label: "tool result",
+					source: s,
+					detail: {
+						role: "toolResult",
+						toolCallId: L(l.call_id),
+						isError: t?.success === !1,
+						publicText: r.text,
+						...r.clip ? { clip: r.clip } : {}
+					}
+				});
+				continue;
+			}
+			if (n.type === "event_msg" && l.type === "token_count" && l.info?.last_token_usage) {
+				let t = l.info.last_token_usage, n = R(t.cached_input_tokens) ?? 0;
+				this.emit({
+					node: e.id,
+					at: o,
+					kind: "usage",
+					category: "other",
+					label: "token count",
+					source: s,
+					detail: {
+						recordType: "event_msg",
+						recordSubtype: "token_count",
+						usage: {
+							input: Math.max(0, (R(t.input_tokens) ?? 0) - n),
+							output: R(t.output_tokens),
+							cacheRead: n,
+							...R(t.reasoning_output_tokens) === void 0 ? {} : { reasoning: t.reasoning_output_tokens }
+						}
+					}
+				});
+				continue;
+			}
+			this.emitRecord(e, o, s, {
+				...l,
+				type: L(n.type) || "line",
+				...l.type ? { subtype: l.type } : {}
+			});
+		}
+		return i.untimed && this.gaps.push({
+			nodeId: e.id,
+			code: "untimed-lines",
+			detail: `${i.untimed} lines of ${this.sourcePath(t)} carry no time`
+		}), i.unparsable && this.gaps.push({
+			nodeId: e.id,
+			code: "unparsable-lines",
+			detail: `${i.unparsable} lines of ${this.sourcePath(t)} are not JSON`
+		}), e.capture = {
+			channel: "codex",
+			status: i.unparsable ? "lossy" : "complete",
+			reason: i.unparsable ? "unparsable-lines" : null
+		}, i;
+	}
+	readParts(e) {
+		let t = e.outRefs.map((e) => this.blob(e)).filter((e) => Array.isArray(e?.value?.events));
+		if (!t.length) return !1;
+		let n = 0;
+		for (let r of t) {
+			let t = this.fileSource(r.rel);
+			this.claim(t.sha256, e.id, r.rel) && (n += this.readPartEvents(e, r.rel, t, r.value.events, {
+				where: (e) => ({ pointer: K("events", e) }),
+				full: (e, t, n) => this.pointerSource(r.rel, K("events", e, ...t), n)
+			}));
+		}
+		return n ? (e.capture = {
+			channel: "part",
+			status: "lossy",
+			reason: "output-parts-final-state"
+		}, !0) : !1;
+	}
+	readPartEvents(e, n, r, i, a) {
+		return t(this, e, n, r, i, a, V);
+	}
+	readRootStream(e) {
+		let t = "root-stream.jsonl", n = v(this.runDir, t);
+		if (!s(n)) return !1;
+		let r = this.file(t), i = H(r.bytes).filter((e) => e.value?.event);
+		if (!i.length || !this.claim(r.sha256, e.id, t)) return !1;
+		this.fileSource(t);
+		let a = (e) => {
+			let t = e.value.event;
+			return `${t.kind}\0${t.toolCallId ?? ""}\0${T(JSON.stringify(t.text ?? t.args ?? t.result ?? ""))}`;
+		}, o = /* @__PURE__ */ new Map();
+		for (let e of i) {
+			let t = Number(e.value.attempt ?? 1), n = o.get(t) ?? [];
+			n.push(e), o.set(t, n);
+		}
+		let c = [], l = [], u = 0;
+		for (let e of [...o.keys()].sort((e, t) => e - t)) {
+			let t = o.get(e), n = 0;
+			for (; n < t.length && n < l.length && a(t[n]) === a(l[n]);) n++;
+			u += n, c.push(...t.slice(n)), l = t;
+		}
+		let d = null, f = 0, p = /* @__PURE__ */ new Set(), m = /* @__PURE__ */ new Set(), h = () => {
+			if (!d) return;
+			let n = d.rows[0], i = d.rows.map((e) => L(e.value.event.text)).join(""), a = P(n.value.at), o = d.rows.at(-1);
+			if (a && i.trim()) {
+				let s = this.clip(i, d.rows.length === 1 ? () => this.lineSource(t, n.line, n.raw) : null);
+				this.emit({
+					node: e.id,
+					at: a,
+					kind: "message",
+					category: "reasoning",
+					label: "assistant",
+					source: {
+						path: t,
+						sha256: r.sha256,
+						line: n.line
+					},
+					detail: {
+						role: "assistant",
+						...n.value.seq === void 0 ? {} : { nativeRecordId: String(n.value.seq) },
+						...d.kind === "text_delta" ? { publicText: s.text } : { reasoning: s.text },
+						...s.clip ? { clip: s.clip } : {},
+						...d.rows.length > 1 ? { anchorRange: [n.line, o.line] } : {}
+					}
+				});
+			}
+			d = null;
+		};
+		for (let n of c) {
+			let i = n.value.event, a = L(i.kind);
+			if (a === "text_delta" || a === "reasoning_delta") {
+				d && d.kind !== a && h(), d ??= {
+					kind: a,
+					rows: []
+				}, d.rows.push(n);
+				continue;
+			}
+			h();
+			let o = P(n.value.at);
+			if (!o) {
+				f++;
+				continue;
+			}
+			let s = {
+				path: t,
+				sha256: r.sha256,
+				line: n.line
+			}, c = n.value.seq === void 0 ? {} : { nativeRecordId: String(n.value.seq) }, l = () => this.lineSource(t, n.line, n.raw);
+			if (a === "tool_call") {
+				let t = i.args === void 0 || i.args === null ? null : this.clip(JSON.stringify(i.args), l);
+				p.add(L(i.toolCallId)), this.emit({
+					node: e.id,
+					at: o,
+					kind: "message",
+					category: V(L(i.toolName), i.args),
+					label: `assistant · ${L(i.toolName)}`,
+					source: s,
+					detail: {
+						role: "assistant",
+						...c,
+						publicToolCalls: [{
+							id: L(i.toolCallId),
+							name: L(i.toolName),
+							...t ? { input: t.text } : {},
+							...t?.clip ? { clip: t.clip } : {}
+						}]
+					}
+				});
+			} else if (a === "tool_result") {
+				let t = i.result, n = typeof t == "string" ? t : t && typeof t == "object" && typeof t.error == "string" && Object.keys(t).length === 1 ? t.error : JSON.stringify(t ?? null), r = this.clip(n, l);
+				m.add(L(i.toolCallId)), this.emit({
+					node: e.id,
+					at: o,
+					kind: "tool-result",
+					category: V(L(i.toolName), null),
+					label: `tool result · ${L(i.toolName)}`,
+					source: s,
+					detail: {
+						role: "toolResult",
+						...c,
+						toolCallId: L(i.toolCallId),
+						isError: !!(t && typeof t == "object" && ("error" in t || t.isError === !0)),
+						publicText: r.text,
+						...r.clip ? { clip: r.clip } : {}
+					}
+				});
+			} else this.emitRecord(e, o, s, {
+				...i,
+				type: a || "event"
+			}, c);
+		}
+		h(), f && this.gaps.push({
+			nodeId: e.id,
+			code: "untimed-lines",
+			detail: `${f} rows of ${this.sourcePath(t)} carry no time`
+		}), u && this.gaps.push({
+			nodeId: e.id,
+			code: "root-replay-dropped",
+			detail: `${u} rows of a resumed attempt repeat its predecessor and are not events`
+		});
+		let g = [...p].filter((e) => !m.has(e)).length;
+		return e.capture = {
+			channel: "root",
+			status: g || u ? "lossy" : "complete",
+			reason: g ? "tool-results-not-streamed" : u ? "resumed-attempt-replay-dropped" : null
+		}, !0;
+	}
+	readFindings(e, t = "kb/pages", n) {
+		let r = n ?? G(v(this.runDir, t)).filter((e) => e.endsWith(".md")).map((e) => `${t}/${e}`), i = this.nodes.get(e);
+		for (let t of r.sort()) {
+			let n = this.file(t);
+			this.fileSource(t);
+			let r = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(n.text), a = (e) => (r ? RegExp(`^${e}:[ \\t]*(.*)$`, "m").exec(r[1])?.[1]?.trim() : void 0) || void 0, o = P(a("createdAt")) ?? P(a("updatedAt")), s = this.manifestFiles.get(this.sourcePath(t))?.mtime, c = o ? null : P(typeof s == "number" && s < 1e11 ? s * 1e3 : s), l = o ?? c;
+			if (!l) {
+				this.gaps.push({
+					nodeId: e,
+					code: "finding-untimed",
+					detail: `${this.sourcePath(t)} has no createdAt and its snapshot records no mtime`
+				});
+				continue;
+			}
+			let u = r ? r.index + r[0].length : 0, d = n.text.slice(u), f = d.trim(), p = n.text.slice(0, u + (d.length - d.trimStart().length)).split("\n").length;
+			i || (i = {
+				id: e,
+				label: "Recorded findings",
+				parent: null,
+				kind: "finding",
+				role: "Findings",
+				model: null,
+				servedModel: null,
+				harness: null,
+				sandboxes: [],
+				capture: {
+					channel: "kb",
+					status: "complete",
+					reason: null
+				},
+				outRefs: [],
+				transcriptRefs: []
+			}, this.nodes.set(e, i));
+			let m = this.clip(f, () => this.fileSource(t)), h = a("title")?.replace(/^(['"])(.*)\1$/, "$2");
+			this.emit({
+				node: e,
+				at: l,
+				kind: "finding-record",
+				category: "verification",
+				label: h ?? g(t, ".md"),
+				source: {
+					path: t,
+					sha256: n.sha256
+				},
+				detail: {
+					...h ? { title: h } : {},
+					createdAt: l,
+					...c ? { atBasis: "snapshot-mtime" } : {},
+					...a("kind") ? { pageKind: a("kind") } : {},
+					bodyLine: p,
+					contentSha256: T(f),
+					recordedClaim: m.text,
+					...m.clip ? { clip: m.clip } : {}
+				}
+			});
+		}
+		return r.length;
+	}
+	convert() {
+		let e = this.runDir, t;
+		try {
+			t = m(e);
+		} catch {
+			throw new S(`Run directory is unreadable: ${e}`);
+		}
+		if (!t.isDirectory()) throw new S(`Not a directory: ${e}`);
+		this.readRunInput(), this.readJournal();
+		let n = this.result = this.resultJson(), r = this.nodes.size > 0, i = G(v(e, "kb/pages")).filter((e) => e.endsWith(".md"));
+		if (!r) {
+			let t = [
+				"result.json",
+				"root-stream.jsonl",
+				"native-trajectory.json",
+				"run-input.json"
+			].some((t) => s(v(e, t))) || G(v(e, "trace")).length > 0;
+			this.format = s(v(e, "native-trajectory.json")) ? "bridge-native" : s(v(e, "failure.json")) ? "failure-only" : s(v(e, "ledger.jsonl")) ? "search" : !t && i.length ? "finding-only" : "other", this.format !== "finding-only" && (this.nodes.set(this.runId, {
+				id: this.runId,
+				label: "root",
+				parent: null,
+				kind: "agent",
+				role: "root",
+				model: null,
+				servedModel: null,
+				harness: null,
+				sandboxes: [],
+				capture: {
+					channel: "journal",
+					status: "absent",
+					reason: "no-spawn-journal"
+				},
+				outRefs: [],
+				transcriptRefs: []
+			}), this.rootId = this.runId, (!t || this.format === "search") && this.gaps.push({
+				nodeId: null,
+				code: "unsupported-format",
+				detail: `No spawn journal in ${this.format === "search" ? "a search ledger" : "this layout"}`
+			}));
+		}
+		let a = this.nodes.get(this.rootId);
+		a && s(v(e, "native-trajectory.json")) && this.format !== "cloud" && (this.format = "bridge-native"), a && G(v(e, "trace/pi-sessions")).some((e) => e.endsWith(".jsonl")) && (this.format = "pi-local");
+		let o = this.runInput;
+		if (a && o?.profile) {
+			let e = o.profile.model;
+			a.model = typeof e == "string" ? e : typeof e?.default == "string" ? e.default : typeof e?.id == "string" ? e.id : a.model, a.modelSource = "run input profile", typeof o.profile.harness == "string" && (a.harness = o.profile.harness);
+		}
+		let c = o?.task, l = typeof c == "string" ? c : typeof c?.instruction == "string" ? c.instruction : typeof c?.objective == "string" ? c.objective : null;
+		a && l && (a.assignment = this.clip(l, null).text);
+		for (let e of this.nodes.values()) {
+			if (e.profileRef) {
+				let t = this.blob(e.profileRef)?.value;
+				if (t && typeof t == "object") {
+					let n = t.model, r = typeof n == "string" ? n : typeof n?.default == "string" ? n.default : null;
+					r && (e.model = r, e.modelSource = "spawn profile"), typeof t.harness == "string" && (e.harness = t.harness);
+				}
+			}
+			if (e.taskDigest && !e.assignment) {
+				let t = this.blob(e.taskDigest);
+				t && typeof t.value == "string" && (e.assignment = this.clip(t.value, null).text);
+			}
+		}
+		a && n?.rootHarnessTranscript?.status === "available" && typeof n.rootHarnessTranscript.transcriptRef == "string" ? a.transcriptRefs.includes(n.rootHarnessTranscript.transcriptRef) || a.transcriptRefs.push(n.rootHarnessTranscript.transcriptRef) : a && typeof n?.rootHarnessTranscript?.reason == "string" && (a.transcriptReason ??= n.rootHarnessTranscript.reason);
+		let u = this.piSessions(), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map();
+		for (let e of this.nodes.values()) e.taskDigest && f.set(e.taskDigest, e.id);
+		let p = /* @__PURE__ */ new Map();
+		for (let [e, t] of this.executionOf) p.set(T(`cli-bridge/pi-session\0${e}`), {
+			...t,
+			sessionId: e
+		});
+		let h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), _ = [];
+		for (let e of u) {
+			let t = /^trace\/pi-sessions\/cli-bridge\/([0-9a-f]{64})\//.exec(e.rel)?.[1], n = t ? p.get(t) : void 0, r = n?.node ?? (e.digest ? f.get(e.digest) : void 0);
+			if (r) {
+				let t = d.get(r) ?? [];
+				t.push(e), d.set(r, t), n ? (h.set(r, "bridge-session-directory"), g.set(r, {
+					journal: {
+						path: this.sourcePath("spawn-journal.jsonl"),
+						line: n.line
+					},
+					session: { path: this.sourcePath(e.rel) },
+					sessionId: n.sessionId
+				})) : h.has(r) || h.set(r, "task-digest");
+			} else _.push(e);
+		}
+		let y = /* @__PURE__ */ new Map();
+		for (let e of this.bridgeStreams()) {
+			let t = e.sessionId ? this.executionOf.get(e.sessionId) : void 0;
+			t && !y.has(t.node) ? y.set(t.node, e) : (this.fileSource(e.rel), this.gaps.push({
+				nodeId: null,
+				code: "bridge-stream-unjoined",
+				detail: `${this.sourcePath(e.rel)} names no materialized session of this run`
+			}));
+		}
+		for (let t of [...this.nodes.values()]) {
+			if (!(t.status !== void 0 || t.id === this.rootId && n) && this.readLiveStream(t)) continue;
+			let r = this.nativeFiles(t);
+			if (Array.isArray(r)) {
+				this.readNative(t, r);
+				continue;
+			}
+			let i = this.nativeStore(t);
+			if (i && this.readOpenCodeStore(t, i) || (r === "not-cached" && this.gaps.push({
+				nodeId: t.id,
+				code: "archived-not-ingested",
+				detail: "A native transcript archive exists but is not in the native cache"
+			}), t.id === this.rootId && s(v(e, "native-trajectory.json")) && this.readOpenCode(t))) continue;
+			let a = d.get(t.id);
+			if (a?.length) {
+				t.joinBasis = h.get(t.id) ?? "task-digest", g.has(t.id) && (t.joinProof = g.get(t.id)), this.readPi(t, a);
+				continue;
+			}
+			let o = y.get(t.id);
+			if (o && this.readBridgeStream(t, o)) {
+				t.joinBasis = "bridge-session-id", t.joinProof = {
+					journal: {
+						path: this.sourcePath("spawn-journal.jsonl"),
+						line: this.executionOf.get(o.sessionId).line
+					},
+					stream: {
+						path: this.sourcePath(o.rel),
+						line: o.sessionLine
+					},
+					sessionId: o.sessionId
+				};
+				continue;
+			}
+			if (this.readParts(t) || t.id === this.rootId && this.readRootStream(t)) continue;
+			let c = r === "not-cached" ? "native-archive-not-cached" : t.transcriptReason ?? (t.outRefs.length ? "no-conversation-in-output" : "no-conversation-channel");
+			t.capture = {
+				channel: "journal",
+				status: "absent",
+				reason: c
+			}, this.gaps.push({
+				nodeId: t.id,
+				code: `no-transcript:${c}`,
+				detail: "Only lifecycle events are recorded for this agent"
+			});
+		}
+		this.readCoordination();
+		for (let e of [
+			"root-stream.jsonl",
+			"native-trajectory.json",
+			"observer.jsonl",
+			"driver-attempts.jsonl",
+			"spans.otlp.jsonl"
+		]) this.listSource(e);
+		for (let e of _) {
+			let t = `pi:${e.sessionId}`;
+			this.nodes.set(t, {
+				id: t,
+				label: `pi ${e.sessionId.slice(0, 8)}`,
+				parent: null,
+				kind: "session",
+				role: "Session",
+				model: null,
+				servedModel: null,
+				harness: "pi",
+				sandboxes: [],
+				capture: {
+					channel: "pi",
+					status: "complete",
+					reason: null
+				},
+				outRefs: [],
+				transcriptRefs: [],
+				joinBasis: "unresolved"
+			}), this.readPi(this.nodes.get(t), [e]), this.nodes.get(t).nativeSessionId = e.sessionId, this.gaps.push({
+				nodeId: t,
+				code: "pi-session-unjoined",
+				detail: "No spawned task digest matches this session"
+			});
+		}
+		i.length && this.readFindings(`finding:${this.runId}`);
+	}
+	readCoordination() {
+		let e = "coordination-log.jsonl";
+		if (!s(v(this.runDir, e))) return;
+		let t = this.file(e);
+		this.fileSource(e);
+		let n = /* @__PURE__ */ new Set();
+		for (let r of H(t.bytes)) {
+			let i = r.value?.event?.type === "instruction" ? r.value.event.instruction : null, a = typeof i?.instruction == "string" ? i.instruction : "", o = typeof i?.toWorker == "string" ? i.toWorker : null, s = P(r.value?.at);
+			if (!i || !s) continue;
+			let c = o ? this.nodes.get(o)?.parent ?? (this.nodes.has(o) ? this.rootId : null) : null;
+			if (!c || !this.nodes.has(c)) {
+				this.gaps.push({
+					nodeId: null,
+					code: "coordination-target-unknown",
+					detail: `${this.sourcePath(e)} line ${r.line} names no spawned worker (${o ?? "no toWorker"})`
+				});
+				continue;
+			}
+			let l = L(i.kind) || "instruction", u = a ? this.clip(a, () => this.lineSource(e, r.line, r.raw)) : {
+				text: "",
+				clip: void 0
+			};
+			if (this.emit({
+				node: c,
+				at: s,
+				kind: "message",
+				category: "coordination",
+				label: `${l} → ${this.nodes.get(o).label}`,
+				source: {
+					path: e,
+					sha256: t.sha256,
+					line: r.line
+				},
+				detail: {
+					role: "assistant",
+					...u.text ? { publicText: u.text } : {},
+					...u.clip ? { clip: u.clip } : {},
+					coordination: {
+						kind: l,
+						toNode: o,
+						receiptId: L(i.receiptId) || null,
+						interrupt: i.interrupt === !0
+					}
+				}
+			}), o && u.text && l !== "interrupt") {
+				let n = this.events.find((e) => e.node === o && e.detail.role === "user" && e.detail.publicText === u.text && Math.abs(Date.parse(e.at) - Date.parse(s)) < 6e4);
+				n ? (n.detail.promptKind = "steering", n.detail.promptSender = "Parent agent") : this.emit({
+					node: o,
+					at: s,
+					kind: "message",
+					category: "other",
+					label: "Steering",
+					source: {
+						path: e,
+						sha256: t.sha256,
+						line: r.line,
+						item: 1
+					},
+					detail: {
+						role: "user",
+						publicText: u.text,
+						...u.clip ? { clip: u.clip } : {},
+						promptKind: "steering",
+						promptSender: "Parent agent",
+						coordination: {
+							kind: l,
+							fromNode: c,
+							receiptId: L(i.receiptId) || null
+						}
+					}
+				});
+			}
+			n.add(c);
+		}
+		for (let e of n) {
+			let t = this.nodes.get(e);
+			if (t.capture.status !== "absent") continue;
+			t.capture = {
+				channel: "coordination",
+				status: "lossy",
+				reason: "instructions-to-workers-only"
+			};
+			let n = this.gaps.findIndex((t) => t.nodeId === e && t.code.startsWith("no-transcript:")), r = {
+				nodeId: e,
+				code: "conversation-not-retained",
+				detail: "Only the instructions this agent sent to its workers were retained (coordination log)"
+			};
+			n >= 0 ? this.gaps[n] = r : this.gaps.push(r);
+		}
+	}
+	result = null;
+	assemble(e = {}) {
+		let t = this.nodes.get(this.rootId), n = this.result, i = this.runInput?.task, a = /* @__PURE__ */ new Map();
+		for (let e of this.events) for (let t of e.detail.publicToolCalls ?? []) a.set(`${e.node}\0${t.id}`, e);
+		for (let e of this.events) {
+			let t = e.detail.toolCallId;
+			if (typeof t != "string") continue;
+			let n = a.get(`${e.node}\0${t}`);
+			if (n && (e.category === "other" && (e.category = n.category), e.detail.durationMs === void 0)) {
+				let t = Date.parse(e.at) - Date.parse(n.at);
+				t >= 0 && e.detail.atBasis !== "carried" && (e.detail.durationMs = t);
+			}
+		}
+		let o = new Map([...this.nodes.keys()].map((e, t) => [e, t])), s = /* @__PURE__ */ new Map();
+		for (let e of this.events) {
+			let t = s.get(e.node);
+			t ? (e.at < t[0] && (t[0] = e.at), e.at > t[1] && (t[1] = e.at)) : s.set(e.node, [e.at, e.at]);
+		}
+		for (let e of this.nodes.values()) {
+			let t = s.get(e.id);
+			!e.start && t && (e.start = t[0]), !e.end && t && e.kind === "session" && (e.end = t[1]);
+		}
+		t && n && !t.status && typeof n.kind == "string" && (t.status = n.kind, t.end ??= s.get(t.id)?.[1]), this.events.sort((e, t) => e.at < t.at ? -1 : e.at > t.at ? 1 : o.get(e.node) - o.get(t.node) || e.order - t.order);
+		let c = /* @__PURE__ */ new Set();
+		for (let e of this.events) {
+			if (c.has(e.id)) throw new w(`duplicate anchor ${e.id} (${e.source.path}${e.source.line ? `:${e.source.line}` : e.source.pointer ?? ""})`);
+			c.add(e.id);
+		}
+		let l = /* @__PURE__ */ new Map();
+		for (let e of this.sources.values()) {
+			if (!e.sha256 || e.line !== void 0 || e.pointer !== void 0) continue;
+			let t = e.sha256.slice(0, 12), n = l.get(t);
+			if (n && n !== e.sha256) throw new w(`object prefix ${t} names two objects`);
+			l.set(t, e.sha256);
+		}
+		let u = [...this.nodes.values()].map((e) => ({
+			nodeId: e.id,
+			...e.capture
+		})), d = {
+			complete: 0,
+			lossy: 0,
+			absent: 0
+		};
+		for (let e of u) d[e.status]++;
+		let f = u.filter((e) => this.nodes.get(e.nodeId)?.kind !== "finding"), p = new Set(this.events.filter((e) => e.kind === "message" && e.detail.role === "assistant" && e.detail.responseStatus !== "error").map((e) => e.node)), m = this.events.some((e) => R(e.detail.costListUsd) !== void 0), h = i?.knowledge, g = i?.completion;
+		return {
+			record: {
+				schema: "agent-record.v1",
+				runId: this.runId,
+				title: e.title ?? this.runId,
+				producer: {
+					name: "@drewstone/agent-record/adapters/agent-runtime",
+					version: y
+				},
+				idScheme: r,
+				input: {
+					...this.options.manifestSha256 ? { snapshot: `sha256:${this.options.manifestSha256}` } : {},
+					runIdBasis: this.runIdBasis,
+					...e.input
+				},
+				format: e.format ?? this.format,
+				nodes: [...this.nodes.values()].map((e) => ({
+					id: e.id,
+					label: e.label,
+					parent: e.parent,
+					kind: e.kind,
+					role: e.role,
+					...e.assignment ? { assignment: e.assignment } : {},
+					model: e.model,
+					...e.modelSource ? { modelSource: e.modelSource } : {},
+					servedModel: p.has(e.id) ? e.servedModel : null,
+					harness: e.harness,
+					...e.start ? { start: e.start } : {},
+					...e.end ? { end: e.end } : {},
+					...e.status ? { status: e.status } : {},
+					...e.nativeSessionId ? { nativeSessionId: e.nativeSessionId } : {},
+					...e.agentId ? { agentId: e.agentId } : {},
+					...e.joinBasis ? { joinBasis: e.joinBasis } : {},
+					...e.joinProof ? { joinProof: e.joinProof } : {},
+					sandboxes: e.sandboxes,
+					capture: e.capture
+				})),
+				events: this.events.map(({ order: e, ...t }) => t),
+				sources: [...this.sources.values()].map(({ sha256: e, ...t }) => e ? {
+					...t,
+					sha256: e
+				} : t).sort((e, t) => e.path < t.path ? -1 : e.path > t.path ? 1 : (e.line ?? 0) - (t.line ?? 0) || (e.pointer ?? "").localeCompare(t.pointer ?? "")),
+				assignment: e.assignment ?? {
+					objective: L(i?.objective),
+					instruction: L(i?.instruction ?? (typeof i == "string" ? i : "")),
+					knowledge: typeof h == "string" ? h : h ? JSON.stringify(h, null, 2) : "",
+					completion: typeof g == "string" ? g : g ? JSON.stringify(g, null, 2) : "",
+					suppliedKnowledge: typeof h == "string" ? h : h ? JSON.stringify(h, null, 2) : "",
+					deliverables: typeof g == "string" ? g : g ? JSON.stringify(g, null, 2) : "",
+					constraints: "",
+					source: this.runInputRel ? {
+						path: this.sourcePath(this.runInputRel),
+						sha256: this.file(this.runInputRel, this.runInputRel.startsWith("../") ? v(_(this.runDir), this.runInputRel.slice(3)) : void 0).sha256,
+						pointer: "/task"
+					} : null
+				},
+				terminal: e.terminal === void 0 ? n ? {
+					kind: typeof n.kind == "string" ? n.kind : null,
+					reason: typeof n.reason == "string" ? n.reason : null,
+					...typeof n.error?.message == "string" ? { error: this.clip(n.error.message, null).text } : {}
+				} : null : e.terminal,
+				coverage: {
+					completeOriginalCapture: f.length > 0 && f.every((e) => e.status === "complete"),
+					publicContent: "",
+					categoryMethod: "Activity types are keyword matches on tool names and commands. They do not measure research value or show independent verification.",
+					cost: m ? "List price from recorded usage; not billed." : "Not recorded",
+					nodes: u,
+					gaps: this.gaps.map((e) => ({
+						runId: this.runId,
+						...e
+					}))
+				}
+			},
+			counts: d
+		};
+	}
+	build() {
+		return this.convert(), this.assemble();
+	}
+};
+function Y(e, t, n = "") {
+	let r = new Map(t.files.filter((e) => e.path.startsWith(n)).map((e) => [e.path.slice(n.length), e])), o = new Set((t.links ?? []).filter((e) => e.path.startsWith(n)).map((e) => e.path.slice(n.length))), c = G(e).filter((e) => !o.has(e)), u = [];
+	for (let e of c) r.has(e) || u.push(`${n}${e} is not in the snapshot`);
+	for (let [t, o] of r) {
+		let r = v(e, t);
+		if (!s(r)) {
+			u.push(`${n}${t} is missing`);
+			continue;
+		}
+		let c = i("sha256"), f = 0, p = l(r, "r");
+		try {
+			let e = Buffer.allocUnsafe(1 << 20);
+			for (let t = d(p, e); t > 0; t = d(p, e)) c.update(e.subarray(0, t)), f += t;
+		} finally {
+			a(p);
+		}
+		(c.digest("hex") !== E(o.sha256) || f !== o.bytes) && u.push(`${n}${t} does not match its sha256 or length`);
+	}
+	if (u.length) throw new w(`${u.length} files differ from the snapshot: ${u.slice(0, 5).join("; ")}`);
+}
+function X(t, n) {
+	let r = e.safeParse(t);
+	if (!r.success) throw Error(`Produced record is invalid: ${r.error.message.slice(0, 2e3)}`);
+	let i = JSON.stringify(t), a = Buffer.byteLength(i);
+	if (a > 134217728) throw new C(`record-too-large: ${a} bytes`);
+	return {
+		record: t,
+		json: i,
+		summary: {
+			runId: t.runId,
+			recordDigest: T(i),
+			bytes: a,
+			nodes: t.nodes.length,
+			events: t.events.length,
+			coverage: n
+		}
+	};
+}
+function Z(e, t = {}) {
+	t.manifest && Y(e, t.manifest);
+	let { record: n, counts: r } = new J(e, t.native, Math.max(1024, t.maxText ?? 16384), {
+		runId: t.runId,
+		manifest: t.manifest,
+		manifestSha256: t.manifestSha256,
+		files: t.files
+	}).build();
+	return X(n, r);
+}
+var Q = "agent-record.bundle.v1", $ = (e, t) => ({
+	id: e,
+	label: e,
+	parent: null,
+	kind: "session",
+	role: "Session",
+	model: null,
+	servedModel: null,
+	harness: null,
+	sandboxes: [],
+	capture: {
+		channel: "none",
+		status: "absent",
+		reason: "no-conversation-channel"
+	},
+	outRefs: [],
+	transcriptRefs: [],
+	...t
+});
+function ee(e) {
+	if (e?.schema !== "agent-record.bundle.v1") throw new S(`bundle.json is not ${Q}`);
+	if (typeof e.recordId != "string" || !e.recordId) throw new S("bundle.json names no recordId");
+	if (!Array.isArray(e.sessions)) throw new S("bundle.json lists no sessions");
+	let t = (e) => typeof e == "string" && e !== "" && !e.startsWith("/") && !e.split("/").includes("..");
+	for (let n of [
+		...e.sessions,
+		...e.journals ?? [],
+		...e.runs ?? [],
+		...e.findings ?? []
+	]) if (!t(n?.path)) throw new S(`bundle.json path ${JSON.stringify(n?.path)} leaves the bundle`);
+	return e;
+}
+function te(e, t = {}) {
+	t.manifest && Y(e, t.manifest);
+	let n = u(v(e, "bundle.json"), "utf8"), r = ee(JSON.parse(n)), i = Math.max(1024, t.maxText ?? 16384), a = new J(e, t.native, i, {
+		runId: r.recordId,
+		manifest: t.manifest,
+		manifestSha256: t.manifestSha256
+	});
+	a.fileSource("bundle.json");
+	for (let n of r.runs ?? []) {
+		let r = new J(v(e, n.path), t.native, i, {
+			runId: n.runId ?? g(n.path),
+			manifest: t.manifest,
+			prefix: `${n.path.replace(/\/+$/, "")}/`
+		});
+		r.convert();
+		for (let [e, t] of r.nodes) {
+			if (a.nodes.has(e)) throw new w(`node ${e} appears twice in the bundle`);
+			a.nodes.set(e, t);
+		}
+		for (let e of r.events) a.events.push({
+			...e,
+			order: a.order++
+		});
+		for (let [e, t] of r.sources) a.sources.has(e) || a.sources.set(e, t);
+		for (let e of r.gaps) a.gaps.push(e);
+		for (let [e, t] of r.claimed) a.claimed.set(e, t);
+	}
+	let o = [], c = /* @__PURE__ */ new Map();
+	for (let e of r.journals ?? []) {
+		let t = a.file(e.path);
+		a.fileSource(e.path);
+		let n = g(_(e.path)), r;
+		if (e.workflow) {
+			a.fileSource(e.workflow);
+			try {
+				r = P(JSON.parse(a.file(e.workflow).text)?.timestamp) ?? void 0;
+			} catch {}
+		}
+		a.nodes.has(n) || a.nodes.set(n, $(n, {
+			label: e.label ?? n,
+			kind: "agent",
+			role: "workflow",
+			harness: "claude-code-workflow",
+			start: r,
+			capture: {
+				channel: "journal",
+				status: "complete",
+				reason: null
+			}
+		}));
+		for (let r of H(t.bytes)) {
+			let i = L(r.value?.agentId);
+			if (!i) continue;
+			let s = `${n}:${i}`;
+			a.nodes.has(s) || (a.nodes.set(s, $(s, {
+				label: `agent ${i.slice(0, 8)}`,
+				parent: n,
+				kind: "agent",
+				role: "workflow agent",
+				agentId: void 0
+			})), c.set(i, {
+				node: s,
+				rel: e.path,
+				line: r.line
+			})), o.push({
+				node: s,
+				rel: e.path,
+				sha256: t.sha256,
+				row: r,
+				type: L(r.value?.type) || "row",
+				agentId: i
+			});
+		}
+	}
+	let l = /* @__PURE__ */ new Map(), d = [];
+	for (let t of r.sessions) {
+		let n;
+		if (t.harness === "claude-code") {
+			let r = H(a.file(t.path).bytes), i = r.find((e) => typeof e.value?.agentId == "string"), o = t.agentId ?? (i ? L(i.value.agentId) : ""), l = t.sessionId ?? L(r.find((e) => typeof e.value?.sessionId == "string")?.value?.sessionId), u = t.path.replace(/\.jsonl$/, ".meta.json"), d = o ? c.get(o) : void 0;
+			if (d && i && g(t.path) === `agent-${o}.jsonl` && s(v(e, u))) n = a.nodes.get(d.node), n.joinBasis = "workflow-agent-id", n.joinProof = {
+				journal: {
+					path: d.rel,
+					line: d.line
+				},
+				session: {
+					path: t.path,
+					line: i.line
+				},
+				meta: { path: u }
+			}, n.nativeSessionId = l || void 0, a.fileSource(u);
+			else {
+				let e = `claude-code:${o || l || g(t.path, ".jsonl")}`;
+				n = a.nodes.get(e) ?? $(e, {
+					label: t.label ?? `claude code ${(o || l).slice(0, 8)}`,
+					nativeSessionId: l || void 0
+				}), a.nodes.set(e, n);
+			}
+			n.harness ??= "claude-code", t.label && (n.label = t.label);
+			let f = a.readClaudeSession(n, t.path, void 0, t.lines);
+			f && (n.capture = {
+				channel: "native",
+				status: f.unparsable ? "lossy" : "complete",
+				reason: f.unparsable ? "unparsable-lines" : t.lines ? "line-window" : null
+			});
+		} else if (t.harness === "codex") {
+			let e = `codex:${t.sessionId ?? g(t.path, ".jsonl")}`;
+			n = a.nodes.get(e) ?? $(e, { label: t.label ?? `codex ${(t.sessionId ?? g(t.path)).slice(-12)}` }), a.nodes.set(e, n), a.readCodex(n, t.path, t.lines) && t.lines && (n.capture = {
+				...n.capture,
+				reason: n.capture.reason ?? "line-window"
+			});
+		} else if (t.harness === "opencode") {
+			let e = `opencode:${t.sessionId ?? g(_(t.path))}`;
+			n = a.nodes.get(e) ?? $(e, { label: t.label ?? e }), a.nodes.set(e, n), a.readOpenCode(n, t.path);
+		} else if (t.harness === "opencode-bridge") {
+			let e = a.file(t.path), r = H(e.bytes), i = r.find((e) => e.value?.table === "sessions"), o = `bridge:${t.sessionId ?? (L(i?.value?.row?.external_id) || g(t.path, ".jsonl"))}`;
+			n = a.nodes.get(o) ?? $(o, { label: t.label ?? o }), a.nodes.set(o, n), a.readBridgeStream(n, {
+				rel: t.path,
+				rows: r,
+				sha256: e.sha256
+			});
+		} else if (t.harness === "pi") {
+			let e = a.file(t.path), r = H(e.bytes), i = r.find((e) => e.value?.type === "session")?.value, o = t.sessionId ?? (L(i?.id) || g(t.path, ".jsonl")), s = `pi:${o}`;
+			n = a.nodes.get(s) ?? $(s, { label: t.label ?? `pi ${o.slice(0, 8)}` }), a.nodes.set(s, n), a.readPi(n, [{
+				rel: t.path,
+				sessionId: o,
+				rows: r,
+				sha256: e.sha256
+			}]);
+		} else throw new S(`bundle.json session ${t.path} has an unknown harness`);
+		l.set(t.path, n.id), d.push({
+			session: t,
+			node: n
+		});
+	}
+	let f = (e) => /(?:^|\/)([0-9a-f-]{36})\/subagents\//.exec(e)?.[1], p = (e, t) => {
+		let n = f(e);
+		return n !== void 0 && g(t, ".jsonl") === n;
+	};
+	for (let { session: e, node: t } of d) {
+		if (!e.parentPath) continue;
+		let n = l.get(e.parentPath);
+		if (!n || !p(e.path, e.parentPath)) {
+			a.gaps.push({
+				nodeId: t.id,
+				code: "parent-unproven",
+				detail: `${e.path} does not sit under ${e.parentPath}`
+			});
+			continue;
+		}
+		let r = t.parent && a.nodes.get(t.parent)?.role === "workflow" ? a.nodes.get(t.parent) : t;
+		r.parent && r.parent !== n || (r.parent = n, r.joinBasis ??= "session-directory");
+	}
+	for (let e of r.journals ?? []) {
+		if (!e.parentPath) continue;
+		let t = l.get(e.parentPath), n = a.nodes.get(g(_(e.path)));
+		t && n && p(e.path, e.parentPath) ? n.parent = t : n && a.gaps.push({
+			nodeId: n.id,
+			code: "parent-unproven",
+			detail: `${e.path} does not sit under ${e.parentPath}`
+		});
+	}
+	let m = /* @__PURE__ */ new Map();
+	for (let e of a.events) {
+		let t = m.get(e.node);
+		t ? (e.at < t[0] && (t[0] = e.at), e.at > t[1] && (t[1] = e.at)) : m.set(e.node, [e.at, e.at]);
+	}
+	for (let e of o) {
+		let t = m.get(e.node);
+		if (!t) {
+			a.gaps.push({
+				nodeId: e.node,
+				code: "journal-untimed-lines",
+				detail: `${e.rel}:${e.row.line} has no time and no joined session`
+			});
+			continue;
+		}
+		let n = a.nodes.get(e.node);
+		e.type === "result" && (n.status ??= "settled");
+		let { type: r, agentId: i, ...o } = e.row.value;
+		a.emit({
+			node: e.node,
+			at: e.type === "started" ? t[0] : t[1],
+			kind: e.type,
+			category: "lifecycle",
+			label: e.type,
+			source: {
+				path: e.rel,
+				sha256: e.sha256,
+				line: e.row.line
+			},
+			detail: {
+				lifecycle: e.type,
+				atBasis: e.type === "started" ? "session-first-event" : "session-last-event",
+				data: a.compactValue(o)
+			}
+		});
+	}
+	for (let e of a.nodes.values()) e.role === "workflow agent" && e.capture.status === "absent" && (e.capture = {
+		channel: "journal",
+		status: "absent",
+		reason: "no-session-joined"
+	}, a.gaps.push({
+		nodeId: e.id,
+		code: "no-transcript:no-session-joined",
+		detail: "No session file carries this workflow agent id"
+	}));
+	for (let t of r.findings ?? []) {
+		let n = t.path.endsWith(".md") ? [t.path] : G(v(e, t.path)).filter((e) => e.endsWith(".md")).map((e) => `${t.path.replace(/\/+$/, "")}/${e}`);
+		a.readFindings(`finding:${r.recordId}`, void 0, n);
+	}
+	a.rootId = "";
+	let { record: h, counts: y } = a.assemble({
+		title: r.title ?? r.recordId,
+		format: "bundle",
+		terminal: null,
+		assignment: {
+			objective: "",
+			instruction: "",
+			knowledge: "",
+			completion: "",
+			suppliedKnowledge: "",
+			deliverables: "",
+			constraints: "",
+			source: null
+		},
+		input: { bundle: `sha256:${T(n)}` }
+	});
+	return X(h, y);
+}
+//#endregion
+export { y as ADAPTER_VERSION, Q as BUNDLE_SCHEMA, r as ID_SCHEME, J as Ingest, b as MAX_RECORD_BYTES, C as RecordTooLargeError, S as RunUnreadableError, w as SnapshotMismatchError, V as categoryOf, x as createFileCache, X as finishRecord, te as ingestBundle, Z as ingestRun, Y as verifySnapshot };