@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/rollout-BOYjemfR.js

@@ -0,0 +1,624 @@
+import { a as ROLLOUT_SPLITS, i as ROLLOUT_SCHEMA, n as ROLLOUT_CAPTURES, r as ROLLOUT_ROLES, u as assertRolloutLine } from "./schema-C6DW4ZHR.js";
+import "./exporters-q9iL-2Jf.js";
+import "./hf-dataset-DBJXXoY1.js";
+import "./mint-yN2M2eh0.js";
+import "./opencode-sqlite-BGrHeDu3.js";
+//#region src/rollout/interchange/harbor.ts
+/**
+* Harbor ATIF-v1.7 interchange — `tangle.rollout.v1` ⇄ Agent Trajectory
+* Interchange Format.
+*
+* ATIF is the portability format (spec:
+* https://www.harborframework.com/docs/agents/trajectory-format, normative
+* RFC: harbor-framework/harbor `rfcs/0001-trajectory-format.md`). It sits
+* BELOW the waist of the rollout hourglass in both directions — export reads
+* `RolloutLine[]`, import writes `RolloutLine[]` — and it is never a source
+* of training labels:
+*
+*   ATIF models NO reward, NO judge verdict, NO task/split coordinates.
+*
+* Consequences, both deliberate:
+*   - EXPORT drops `outcome.reward`, `outcome.reward_source` and
+*     `outcome.verdict` entirely. They are not smuggled into `extra`: a
+*     third-party reading our ATIF file must not be able to mistake an
+*     agent-eval judge score for something ATIF sanctioned.
+*   - IMPORT therefore mints UNLABELED lines: `reward: null` (the existing
+*     "null reward is a labeled gap, never 0" semantics), `verdict: null`,
+*     and a `provenance.gap` naming the missing label. An imported
+*     trajectory is not a training example until a judge scores it.
+*
+* Everything else we own that ATIF has no field for travels in a namespaced
+* escrow at `extra.tangle.*`, so our own round-trip is exact while a foreign
+* reader can ignore it. Fields that neither ATIF nor the escrow can carry
+* come back explicitly null / fail-closed, never invented.
+*
+* THE ESCROW IS NAMESPACED, NOT AUTHENTICATED. Anyone can write
+* `extra.tangle.*` into a file. So the escrow may restore what a value IS, but
+* never what a line is ALLOWED to do: `task.split` is forced to `holdout` on
+* every import regardless of what the document claims, and promoting an
+* imported trajectory to a trainable split is an explicit, greppable act
+* (`relabelImportedSplit`) rather than a property of the file. The document
+* keeps its claim — the claim just is not authority.
+*
+* Multi-agent shape differs on purpose. ATIF EMBEDS children in
+* `subagent_trajectories`; we keep a flat ledger with a normalized
+* `parent_rollout_id` edge. Export assembles the tree, import flattens it.
+* `session_id` is RUN-scoped in ATIF, so it carries `run_id` — the coordinate
+* that is shared by every invocation of one run — not `rollout_id`, which
+* identifies a single invocation and would split one run across session ids.
+*
+* ROUND-TRIPPING IS IDEMPOTENT: `import(export(import(export(x))))` is
+* byte-identical to `import(export(x))`. Import composes `provenance.gap` as a
+* de-duplicated ordered set rather than appending, and it emits every
+* `ChatMessage` with keys in the canonical schema order (role, content,
+* reasoning_content, tool_calls, tool_call_id, name, is_copied_context), so a
+* ledger hashed on serialized bytes sees no diff across further passes. The
+* FIRST import may re-order a producer's keys — that is the canonicalization.
+*
+* NOT building a Letta converter. Letta's trajectory-v1 is a strict subset of
+* what we need from ATIF here — no per-step or aggregate cost, no
+* multi-agent/subagent structure, no token-id or logprob channel — so a Letta
+* sink would carry less than this one and add a second format to keep
+* correct. Decision recorded in docs/rollout.md; do not re-litigate without a
+* concrete consumer that reads Letta and cannot read ATIF.
+*/
+const ATIF_SCHEMA_VERSION = "ATIF-v1.7";
+/** Gap note on every imported line — ATIF carries no verdict, so nothing is scored. */
+const HARBOR_IMPORT_GAP = "imported from Harbor ATIF; no verdict";
+/** Namespaced escrow key for everything ATIF does not model but we must not lose. */
+const ESCROW = "tangle";
+/**
+* Marks a step we synthesized purely to hold tool results that answered no
+* assistant turn IN THIS DOCUMENT. ATIF has no `tool` source, so such results
+* need a carrier step; the marker lets import drop the carrier instead of
+* inventing a turn.
+*
+* A carrier's results carry NO `source_call_id`. RFC 0001 rule 2 requires every
+* `source_call_id` to match a `tool_call_id` in the same step's `tool_calls`,
+* and a carrier declares no calls (a `system` step cannot legally make one), so
+* emitting the id there would produce an invalid document. The id is escrowed
+* instead and restored verbatim on import — the link survives without the
+* document lying about who made the call.
+*/
+const TOOL_RESULTS_ONLY = "tool-results-only";
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const asString = (v) => typeof v === "string" ? v : void 0;
+const asNumberOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+const asIntegerOrUndefined = (v) => Number.isInteger(v) ? v : void 0;
+const asNumberArray = (v) => Array.isArray(v) && v.every((n) => typeof n === "number" && Number.isFinite(n)) ? v : void 0;
+const asIntegerArray = (v) => Array.isArray(v) && v.every((n) => Number.isInteger(n)) ? v : void 0;
+/**
+* Builds a `ChatMessage` with keys in the schema's declaration order.
+*
+* Object key order is insertion order in JS, so a message assembled
+* conditionally field-by-field serializes differently depending on which
+* optional fields were present — which makes a byte-hashed ledger see a diff
+* across an import that changed nothing. One builder, one order, stable bytes.
+*/
+function canonicalChatMessage(parts) {
+	const message = {
+		role: parts.role,
+		content: parts.content
+	};
+	if (parts.reasoning_content !== void 0) message.reasoning_content = parts.reasoning_content;
+	if (parts.tool_calls !== void 0) message.tool_calls = parts.tool_calls;
+	if (parts.tool_call_id !== void 0) message.tool_call_id = parts.tool_call_id;
+	if (parts.name !== void 0) message.name = parts.name;
+	if (parts.is_copied_context === true) message.is_copied_context = true;
+	return message;
+}
+/** Reads the `extra.tangle` escrow, tolerating a foreign file that has none. */
+function escrowOf(extra) {
+	if (!isRecord(extra)) return void 0;
+	const value = extra[ESCROW];
+	return isRecord(value) ? value : void 0;
+}
+function escrowSection(escrow, key) {
+	if (escrow === void 0) return void 0;
+	const value = escrow[key];
+	return isRecord(value) ? value : void 0;
+}
+function toHarborToolCall(call) {
+	let parsed;
+	try {
+		const decoded = JSON.parse(call.function.arguments);
+		if (isRecord(decoded)) parsed = decoded;
+	} catch {
+		parsed = void 0;
+	}
+	return {
+		tool_call_id: call.id,
+		function_name: call.function.name,
+		arguments: parsed ?? {},
+		extra: { [ESCROW]: { arguments_raw: call.function.arguments } }
+	};
+}
+/**
+* `linked` = this result is attached to the step that actually declared the
+* call, so `source_call_id` is legal (RFC 0001 rule 2). When it is not, the id
+* goes to escrow instead of onto the wire.
+*/
+function toObservationResult(message, linked) {
+	const result = {};
+	if (linked && message.tool_call_id !== void 0) result.source_call_id = message.tool_call_id;
+	if (message.content !== null) result.content = message.content;
+	const escrow = {};
+	if (!linked && message.tool_call_id !== void 0) escrow.source_call_id = message.tool_call_id;
+	if (message.name !== void 0) escrow.name = message.name;
+	if (message.content === null) escrow.content_null = true;
+	if (message.reasoning_content !== void 0) escrow.reasoning_content = message.reasoning_content;
+	if (message.is_copied_context === true) escrow.is_copied_context = true;
+	if (Object.keys(escrow).length > 0) result.extra = { [ESCROW]: escrow };
+	return result;
+}
+/** True when `step` is the agent turn that declared `callId` — the rule-2 test. */
+function declaresCall(step, callId) {
+	if (callId === void 0) return false;
+	return step.tool_calls?.some((call) => call.tool_call_id === callId) === true;
+}
+/**
+* Attaches the four RL fields lifted from ATIF onto the agent step the span
+* describes. They are ALSO escrowed with the whole span under `extra.tangle`,
+* on purpose: the escrow is how our own round-trip stays exact, and these
+* native fields are how a foreign consumer — which never reads our escrow —
+* gets the logprobs and token ids at all. A field carried only in the escrow is
+* not an interchange field.
+*/
+function applySpanMetrics(step, span) {
+	if (span === void 0) return;
+	if (span.llm_call_count !== void 0) step.llm_call_count = span.llm_call_count;
+	const metrics = {};
+	if (span.prompt_token_ids !== void 0) metrics.prompt_token_ids = span.prompt_token_ids;
+	if (span.completion_token_ids !== void 0) metrics.completion_token_ids = span.completion_token_ids;
+	if (span.logprobs !== void 0) metrics.logprobs = span.logprobs;
+	if (Object.keys(metrics).length > 0) step.metrics = metrics;
+}
+/**
+* Coalescing fold, not a 1:1 map: ATIF has no `tool` source, so a tool result
+* becomes an `observation.results[]` entry on the agent step THAT DECLARED ITS
+* `tool_call_id`.
+*
+* Linking by id, not by adjacency. Adjacency emitted invalid documents in three
+* shapes the RFC forbids — an assistant turn with no `tool_calls` swallowing the
+* results that followed it, a result whose id matched none of the preceding
+* step's calls, and an unanswered result riding a `system` step that carried a
+* `source_call_id` it could never declare. Attaching only to the step that owns
+* the id also preserves message order exactly: a result either joins the step
+* immediately before it or becomes its own carrier at its own position.
+*
+* `line.steps` span projections are matched to agent steps in order (k-th llm
+* span → k-th agent step) purely to fill ATIF's native per-step `metrics`;
+* extra spans on either side are simply not matched, never invented.
+*/
+function messagesToSteps(line) {
+	const steps = [];
+	const llmSpans = (line.steps ?? []).filter((span) => span.kind === "llm");
+	let nextSpan = 0;
+	for (const message of line.messages) {
+		if (message.role === "tool") {
+			const previous = steps[steps.length - 1];
+			if (previous !== void 0 && declaresCall(previous, message.tool_call_id)) {
+				if (previous.observation === void 0) previous.observation = { results: [] };
+				previous.observation.results.push(toObservationResult(message, true));
+				continue;
+			}
+			const carrier = {
+				step_id: steps.length + 1,
+				source: "system",
+				message: "",
+				observation: { results: [toObservationResult(message, false)] },
+				extra: { [ESCROW]: { synthetic: TOOL_RESULTS_ONLY } }
+			};
+			if (message.is_copied_context === true) carrier.is_copied_context = true;
+			steps.push(carrier);
+			continue;
+		}
+		const step = {
+			step_id: steps.length + 1,
+			source: message.role === "assistant" ? "agent" : message.role,
+			message: message.content ?? ""
+		};
+		const escrow = {};
+		if (message.content === null) escrow.content_null = true;
+		if (message.name !== void 0) escrow.name = message.name;
+		if (message.role === "assistant") {
+			if (line.policy.model !== null) step.model_name = line.policy.model;
+			if (message.reasoning_content !== void 0) step.reasoning_content = message.reasoning_content;
+			if (message.tool_calls !== void 0 && message.tool_calls.length > 0) step.tool_calls = message.tool_calls.map(toHarborToolCall);
+			applySpanMetrics(step, llmSpans[nextSpan]);
+			nextSpan += 1;
+		} else if (message.reasoning_content !== void 0) escrow.reasoning_content = message.reasoning_content;
+		if (message.is_copied_context === true) step.is_copied_context = true;
+		if (Object.keys(escrow).length > 0) step.extra = { [ESCROW]: escrow };
+		steps.push(step);
+	}
+	return steps;
+}
+function finalMetricsOf(line, stepCount) {
+	const metrics = {};
+	if (line.cost.tokens_in !== null) metrics.total_prompt_tokens = line.cost.tokens_in;
+	if (line.cost.tokens_out !== null) metrics.total_completion_tokens = line.cost.tokens_out;
+	if (line.cost.cache_read !== null) metrics.total_cached_tokens = line.cost.cache_read;
+	if (line.cost.usd !== null) metrics.total_cost_usd = line.cost.usd;
+	metrics.total_steps = stepCount;
+	const extra = {};
+	if (line.cost.tokens_reasoning !== null) extra.reasoning_tokens = line.cost.tokens_reasoning;
+	if (line.cost.cache_write !== null) extra.cache_write_tokens = line.cost.cache_write;
+	if (line.cost.wall_s !== null) extra.wall_s = line.cost.wall_s;
+	if (line.cost.llm_call_count !== void 0 && line.cost.llm_call_count !== null) extra.llm_call_count = line.cost.llm_call_count;
+	if (Object.keys(extra).length > 0) metrics.extra = extra;
+	return metrics;
+}
+function notesOf(line) {
+	const parts = [];
+	if (line.provenance.gap !== void 0) parts.push(line.provenance.gap);
+	if (line.outcome.realness_gated === true) parts.push("realness-gated: this run faked its success signal (anti-Goodhart gate fired)");
+	return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function toTrajectoryNode(line) {
+	const steps = messagesToSteps(line);
+	const trajectory = {
+		schema_version: ATIF_SCHEMA_VERSION,
+		session_id: line.run_id,
+		trajectory_id: line.rollout_id,
+		agent: {
+			name: line.policy.harness ?? "unknown",
+			version: line.policy.harness_version ?? "0.0.0",
+			...line.policy.model !== null ? { model_name: line.policy.model } : {},
+			...line.tool_defs.length > 0 ? { tool_definitions: line.tool_defs } : {}
+		},
+		steps,
+		final_metrics: finalMetricsOf(line, steps.length),
+		extra: { [ESCROW]: {
+			schema: line.schema,
+			rollout_id: line.rollout_id,
+			parent_rollout_id: line.parent_rollout_id,
+			run_id: line.run_id,
+			...line.experiment_id !== void 0 ? { experiment_id: line.experiment_id } : {},
+			...line.candidate_id !== void 0 ? { candidate_id: line.candidate_id } : {},
+			generation: line.generation,
+			candidate_index: line.candidate_index,
+			role: line.role,
+			task: line.task,
+			policy: line.policy,
+			...line.steps !== void 0 ? { spans: line.steps } : {},
+			outcome: {
+				metrics: line.outcome.metrics,
+				is_completed: line.outcome.is_completed,
+				is_truncated: line.outcome.is_truncated,
+				error: line.outcome.error,
+				...line.outcome.realness_gated !== void 0 ? { realness_gated: line.outcome.realness_gated } : {}
+			},
+			artifacts: line.artifacts,
+			provenance: line.provenance
+		} }
+	};
+	const notes = notesOf(line);
+	if (notes !== void 0) trajectory.notes = notes;
+	return trajectory;
+}
+function buildForest(lines) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		if (byId.has(line.rollout_id)) throw new Error(`duplicate rollout_id in input: ${line.rollout_id}`);
+		byId.set(line.rollout_id, line);
+	}
+	const roots = [];
+	const childrenOf = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const parent = line.parent_rollout_id;
+		if (parent === null || !byId.has(parent)) {
+			roots.push(line);
+			continue;
+		}
+		const siblings = childrenOf.get(parent);
+		if (siblings === void 0) childrenOf.set(parent, [line]);
+		else siblings.push(line);
+	}
+	if (lines.length > 0 && roots.length === 0) throw new Error(`parent_rollout_id cycle: no root among ${lines.length} lines (${lines.map((l) => l.rollout_id).join(", ")})`);
+	return {
+		roots,
+		childrenOf
+	};
+}
+function assemble(line, forest, onPath) {
+	if (onPath.has(line.rollout_id)) throw new Error(`parent_rollout_id cycle through rollout_id ${line.rollout_id}`);
+	onPath.add(line.rollout_id);
+	const node = toTrajectoryNode(line);
+	const children = forest.childrenOf.get(line.rollout_id);
+	if (children !== void 0 && children.length > 0) node.subagent_trajectories = children.map((child) => assemble(child, forest, onPath));
+	onPath.delete(line.rollout_id);
+	return node;
+}
+/**
+* Assemble one episode's flat lines into a single ATIF trajectory tree,
+* linked by `parent_rollout_id`.
+*
+* Reward, verdict and split are NOT emitted (ATIF models none of them); the
+* split and the rest of the task coordinates survive only in `extra.tangle`.
+*
+* We deliberately do NOT synthesize an `observation.subagent_trajectory_ref`
+* pointing at each child: our ledger records WHICH invocation spawned a
+* worker, not which STEP did, and attaching the ref to a guessed step would
+* fabricate a causal claim. Children are embedded in `subagent_trajectories`
+* (each with the `trajectory_id` the spec requires) and the edge is stated in
+* the child's escrowed `parent_rollout_id`.
+*
+* Throws when the lines are not one tree — use `toHarborTrajectories` for a forest.
+*/
+function toHarborTrajectory(lines) {
+	const trees = toHarborTrajectories(lines);
+	if (trees.length === 0) throw new Error("toHarborTrajectory: no lines");
+	if (trees.length > 1) {
+		const ids = trees.map((t) => t.trajectory_id ?? "?").join(", ");
+		throw new Error(`toHarborTrajectory: ${trees.length} roots (${ids}) — ATIF is one tree per document; use toHarborTrajectories`);
+	}
+	return trees[0];
+}
+/** Every independent tree in the input, one ATIF document each. */
+function toHarborTrajectories(lines) {
+	const forest = buildForest(lines);
+	return forest.roots.map((root) => assemble(root, forest, /* @__PURE__ */ new Set()));
+}
+function contentToString(message) {
+	if (typeof message === "string") return message;
+	return message.map((part) => part.type === "image" ? `[image ${part.source?.media_type ?? "unknown"} ${part.source?.path ?? ""}]`.trim() : part.text ?? "").join("\n");
+}
+function fromHarborToolCall(call) {
+	const raw = asString(escrowOf(call.extra)?.arguments_raw);
+	return {
+		id: call.tool_call_id,
+		type: "function",
+		function: {
+			name: call.function_name,
+			arguments: raw ?? JSON.stringify(call.arguments ?? {})
+		}
+	};
+}
+function fromObservationResult(result, callId) {
+	const escrow = escrowOf(result.extra);
+	return canonicalChatMessage({
+		role: "tool",
+		content: escrow?.content_null === true ? null : result.content === void 0 ? "" : contentToString(result.content),
+		reasoning_content: asString(escrow?.reasoning_content),
+		tool_call_id: callId,
+		name: asString(escrow?.name),
+		is_copied_context: escrow?.is_copied_context === true
+	});
+}
+function stepsToMessages(steps) {
+	const messages = [];
+	for (const step of steps) {
+		const escrow = escrowOf(step.extra);
+		const carrierOnly = escrow?.synthetic === TOOL_RESULTS_ONLY;
+		if (!carrierOnly) messages.push(canonicalChatMessage({
+			role: step.source === "agent" ? "assistant" : step.source,
+			content: escrow?.content_null === true ? null : contentToString(step.message),
+			reasoning_content: step.reasoning_content ?? asString(escrow?.reasoning_content),
+			tool_calls: step.tool_calls !== void 0 && step.tool_calls.length > 0 ? step.tool_calls.map(fromHarborToolCall) : void 0,
+			name: asString(escrow?.name),
+			is_copied_context: step.is_copied_context === true
+		}));
+		for (const result of step.observation?.results ?? []) {
+			const resultEscrow = escrowOf(result.extra);
+			const callId = result.source_call_id ?? asString(resultEscrow?.source_call_id);
+			if (carrierOnly) {
+				messages.push(fromObservationResult(result, callId));
+				continue;
+			}
+			if (typeof callId === "string") {
+				messages.push(fromObservationResult(result, callId));
+				continue;
+			}
+			if (result.content !== void 0) messages.push(canonicalChatMessage({
+				role: "system",
+				content: contentToString(result.content)
+			}));
+		}
+	}
+	return messages;
+}
+function taskFrom(escrow, fallbackId) {
+	const task = escrowSection(escrow, "task");
+	return {
+		suite: asString(task?.suite) ?? "harbor-atif-import",
+		instance_id: asString(task?.instance_id) ?? fallbackId,
+		split: "holdout",
+		seed: asNumberOrNull(task?.seed),
+		rep: asIntegerOrUndefined(task?.rep) ?? 0
+	};
+}
+function policyFrom(escrow, agent) {
+	const escrowed = escrowSection(escrow, "policy");
+	if (escrowed !== void 0) return {
+		harness: asString(escrowed.harness) ?? null,
+		harness_version: asString(escrowed.harness_version) ?? null,
+		model: asString(escrowed.model) ?? null,
+		provider: asString(escrowed.provider) ?? null,
+		profile_commit: asString(escrowed.profile_commit) ?? null,
+		...escrowed.prompt_hash !== void 0 ? { prompt_hash: asString(escrowed.prompt_hash) ?? null } : {},
+		...escrowed.config_hash !== void 0 ? { config_hash: asString(escrowed.config_hash) ?? null } : {},
+		...escrowed.agent_profile_cell_id !== void 0 ? { agent_profile_cell_id: asString(escrowed.agent_profile_cell_id) ?? null } : {},
+		sampling: isRecord(escrowed.sampling) ? escrowed.sampling : null
+	};
+	return {
+		harness: agent.name,
+		harness_version: agent.version,
+		model: agent.model_name ?? null,
+		provider: null,
+		profile_commit: null,
+		sampling: null
+	};
+}
+function artifactsFrom(escrow) {
+	const artifacts = escrowSection(escrow, "artifacts");
+	return {
+		patch_path: asString(artifacts?.patch_path) ?? null,
+		run_dir: asString(artifacts?.run_dir) ?? null,
+		transcript_ref: asString(artifacts?.transcript_ref) ?? null
+	};
+}
+function costFrom(final) {
+	const rawExtra = final?.extra;
+	const extra = isRecord(rawExtra) ? rawExtra : void 0;
+	const calls = asIntegerOrUndefined(extra?.llm_call_count);
+	return {
+		usd: asNumberOrNull(final?.total_cost_usd),
+		tokens_in: asNumberOrNull(final?.total_prompt_tokens),
+		tokens_out: asNumberOrNull(final?.total_completion_tokens),
+		tokens_reasoning: asNumberOrNull(extra?.reasoning_tokens),
+		cache_read: asNumberOrNull(final?.total_cached_tokens),
+		cache_write: asNumberOrNull(extra?.cache_write_tokens),
+		wall_s: asNumberOrNull(extra?.wall_s),
+		...calls !== void 0 ? { llm_call_count: calls } : {}
+	};
+}
+/**
+* Recovers span projections from ATIF's NATIVE per-step channel, for documents
+* with no `extra.tangle.spans` escrow — i.e. everything a foreign producer
+* writes. Without this the logprobs and token ids a Harbor-native trainer
+* records would be read, validated, and then dropped on the floor.
+*
+* Only steps that actually carry one of the four fields produce a span: an
+* agent step with no metrics means "not captured", and inventing an empty span
+* for it would claim the run had a shape we did not observe.
+*/
+function spansFromSteps(steps) {
+	const spans = [];
+	for (const step of steps) {
+		if (step.source !== "agent") continue;
+		const calls = asIntegerOrUndefined(step.llm_call_count);
+		const promptIds = asIntegerArray(step.metrics?.prompt_token_ids);
+		const completionIds = asIntegerArray(step.metrics?.completion_token_ids);
+		const logprobs = asNumberArray(step.metrics?.logprobs);
+		if (calls === void 0 && promptIds === void 0 && completionIds === void 0 && logprobs === void 0) continue;
+		spans.push({
+			kind: "llm",
+			name: step.model_name ?? "chat",
+			...calls !== void 0 ? { llm_call_count: calls } : {},
+			...promptIds !== void 0 ? { prompt_token_ids: promptIds } : {},
+			...completionIds !== void 0 ? { completion_token_ids: completionIds } : {},
+			...logprobs !== void 0 ? { logprobs } : {}
+		});
+	}
+	return spans;
+}
+/**
+* Composes `provenance.gap` as an ordered SET of reasons.
+*
+* Appending made the note accrete on every pass ("…no verdict | …no verdict"),
+* which both grows without bound and breaks byte-level idempotency for a ledger
+* hashed on its serialized lines.
+*/
+function composeGap(escrowedGap, added) {
+	const parts = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const raw of [...escrowedGap?.split(" | ") ?? [], ...added]) {
+		const reason = raw.trim();
+		if (reason.length === 0 || seen.has(reason)) continue;
+		seen.add(reason);
+		parts.push(reason);
+	}
+	return parts.join(" | ");
+}
+function nodeToLine(trajectory, parentId, capturedAt) {
+	const escrow = escrowOf(trajectory.extra);
+	const rolloutId = asString(escrow?.rollout_id) ?? trajectory.trajectory_id ?? trajectory.session_id;
+	if (rolloutId === void 0 || rolloutId.length === 0) throw new Error("fromHarborTrajectory: trajectory has no trajectory_id or session_id — cannot mint a joinable rollout_id without inventing one");
+	const outcome = escrowSection(escrow, "outcome");
+	const provenance = escrowSection(escrow, "provenance");
+	const capture = provenance?.capture;
+	const escrowedGap = asString(provenance?.gap);
+	const role = escrow?.role;
+	const escrowedSpans = escrow?.spans;
+	const nativeSpans = spansFromSteps(trajectory.steps);
+	const spans = Array.isArray(escrowedSpans) ? escrowedSpans : nativeSpans.length > 0 ? nativeSpans : void 0;
+	const messages = stepsToMessages(trajectory.steps);
+	const line = {
+		schema: ROLLOUT_SCHEMA,
+		rollout_id: rolloutId,
+		parent_rollout_id: parentId ?? asString(escrow?.parent_rollout_id) ?? null,
+		run_id: asString(escrow?.run_id) ?? trajectory.session_id ?? rolloutId,
+		experiment_id: asString(escrow?.experiment_id) ?? null,
+		candidate_id: asString(escrow?.candidate_id) ?? null,
+		generation: asIntegerOrUndefined(escrow?.generation) ?? null,
+		candidate_index: asIntegerOrUndefined(escrow?.candidate_index) ?? null,
+		role: ROLLOUT_ROLES.includes(role) ? role : "agent",
+		task: taskFrom(escrow, rolloutId),
+		policy: policyFrom(escrow, trajectory.agent),
+		messages,
+		tool_defs: trajectory.agent.tool_definitions ?? [],
+		...spans !== void 0 ? { steps: spans } : {},
+		outcome: {
+			reward: null,
+			reward_source: null,
+			verdict: null,
+			metrics: isRecord(outcome?.metrics) ? outcome.metrics : {},
+			is_completed: typeof outcome?.is_completed === "boolean" ? outcome.is_completed : true,
+			is_truncated: typeof outcome?.is_truncated === "boolean" ? outcome.is_truncated : trajectory.continued_trajectory_ref !== void 0,
+			error: asString(outcome?.error) ?? null,
+			realness_gated: outcome?.realness_gated === true
+		},
+		cost: costFrom(trajectory.final_metrics),
+		artifacts: artifactsFrom(escrow),
+		provenance: {
+			captured_at: asString(provenance?.captured_at) ?? capturedAt,
+			capture: ROLLOUT_CAPTURES.includes(capture) ? capture : "backfill",
+			gap: composeGap(escrowedGap, [HARBOR_IMPORT_GAP]),
+			...isRecord(provenance?.gated_evidence) ? { gated_evidence: provenance.gated_evidence } : {}
+		}
+	};
+	assertRolloutLine(line, `rollout line imported from ATIF trajectory ${rolloutId}`);
+	return line;
+}
+/**
+* Flatten an ATIF trajectory tree back into `tangle.rollout.v1` lines, parent
+* first, each child carrying `parent_rollout_id`.
+*
+* Every line comes back UNLABELED: `reward`, `reward_source` and `verdict` are
+* null and `provenance.gap` says why. ATIF models no verdict, so scoring an
+* imported trajectory is a judge's job, not this function's. Every line lands
+* on `holdout` whatever the document claims — see `relabelImportedSplit`.
+*/
+function fromHarborTrajectory(trajectory, options = {}) {
+	const capturedAt = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+	const lines = [];
+	const walk = (node, parentId, onPath) => {
+		const line = nodeToLine(node, parentId, capturedAt);
+		if (onPath.has(line.rollout_id)) throw new Error(`subagent_trajectories cycle through trajectory_id ${line.rollout_id}`);
+		onPath.add(line.rollout_id);
+		lines.push(line);
+		for (const child of node.subagent_trajectories ?? []) walk(child, line.rollout_id, onPath);
+		onPath.delete(line.rollout_id);
+	};
+	walk(trajectory, null, /* @__PURE__ */ new Set());
+	return lines;
+}
+/**
+* THE explicit door out of `holdout` for imported lines.
+*
+* Import forces `holdout` because a document's own claim about its split is not
+* evidence — anyone can write `extra.tangle.task.split`. Promoting a file to a
+* trainable split is an operator's decision about provenance they verified, so
+* it is a separate, greppable call: `grep relabelImportedSplit` enumerates
+* every place foreign data was declared trainable, which is exactly the audit
+* the trusted-escrow version made impossible.
+*
+* Returns plain `RolloutLine`s. They still have to pass `assertMinted` (and its
+* anti-Goodhart check) to reach an exporter — re-labeling a split is not
+* minting a reward.
+*/
+function relabelImportedSplit(lines, split) {
+	if (!ROLLOUT_SPLITS.includes(split)) throw new Error(`relabelImportedSplit: unknown split ${String(split)}`);
+	return lines.map((line) => ({
+		...line,
+		task: {
+			...line.task,
+			split
+		}
+	}));
+}
+//#endregion
+export { toHarborTrajectories as a, relabelImportedSplit as i, HARBOR_IMPORT_GAP as n, toHarborTrajectory as o, fromHarborTrajectory as r, ATIF_SCHEMA_VERSION as t };
+
+//# sourceMappingURL=rollout-BOYjemfR.js.map