@rulvar/core 1.230.0 → 1.232.0

package/dist/index.js

@@ -8794,11 +8794,25 @@ function readRejectedFinishCandidates(raw) {
 *
 * The twenty-fifth comparison run was killed and resumed, and its two
 * terminals mixed both kinds with nothing marking which was which: the
-* money was cumulative, the wake count and the replay figures were not,
+* money was cumulative, the live-only counters were not,
 * and reconciling them into one honest account of the logical run was
 * hand work over a joined journal. Keys are field paths as a consumer
-* reads them off `RunOutcome` (`cost.orchestrator.wakes`), and
-* {@link TerminalTelemetryScopes} requires every one of them.
+* reads them off `RunOutcome` (`cost.orchestrator.wakes`): the type
+* requires every field of the outcome, and the `satisfies` below
+* requires every counted leaf under `cost` (RV2801), because an index
+* signature admits nested paths and demands none, so the five that were
+* declared were declared by hand and by luck while four
+* (`cost.usageApprox`, `cost.abandoned.usd`, `cost.abandoned.usageApprox`,
+* `cost.orchestrator.share`) were simply missing. That is the RV2701
+* blindness one level down: a gate whose subject is nested figures
+* cannot stop at the top level.
+*
+* What neither can decide is whether a declared scope is TRUE, and a
+* wrong scope is worse than a missing one: a missing one is noticed, a
+* wrong one is believed. The doctrine test suspends a real run, resumes
+* it, and holds every declared figure against its own claim (RV2801),
+* which is how three `cost.orchestrator.*` paths were found calling
+* themselves `'segment'` while the terminal folded them cumulatively.
 */
 const TERMINAL_TELEMETRY_SCOPE = Object.freeze({
 	status: "terminal",
@@ -8827,10 +8841,14 @@ const TERMINAL_TELEMETRY_SCOPE = Object.freeze({
 	"cost.totalUsd": "cumulative",
 	"cost.grossUsd": "cumulative",
 	"cost.wireRequests": "cumulative",
+	"cost.usageApprox": "cumulative",
+	"cost.abandoned.usd": "cumulative",
+	"cost.abandoned.usageApprox": "cumulative",
 	"cost.orchestrator.spentUsd": "cumulative",
-	"cost.orchestrator.wakes": "segment",
-	"cost.orchestrator.forcedFinish": "segment",
-	"cost.orchestrator.reserveUsedUsd": "segment",
+	"cost.orchestrator.share": "cumulative",
+	"cost.orchestrator.wakes": "cumulative",
+	"cost.orchestrator.forcedFinish": "cumulative",
+	"cost.orchestrator.reserveUsedUsd": "cumulative",
 	transportRetries: "segment",
 	schemaRejectedFinishExchanges: "segment",
 	schemaRecoveredFinishExchanges: "segment"
@@ -8905,6 +8923,7 @@ function logicalRunTelemetry(entries) {
 function childRostersFromJournal(entries) {
 	const rosters = /* @__PURE__ */ new Map();
 	const ordered = [...entries].sort((a, b) => a.seq - b.seq);
+	const abandoned = buildAbandonFold(ordered);
 	const dispatchesByScope = /* @__PURE__ */ new Map();
 	const terminalsByScopeKey = /* @__PURE__ */ new Map();
 	for (const entry of ordered) {
@@ -8950,6 +8969,7 @@ function childRostersFromJournal(entries) {
 		const terminal = terminalsByScopeKey.get(JSON.stringify([childScope, dispatch.key]))?.find((candidate) => candidate.seq > dispatch.seq);
 		roster.children.push({
 			handle: dispatch.seq,
+			...abandoned.isAbandoned(dispatch.seq) ? { abandoned: true } : {},
 			...terminal?.costAttribution?.agentType === void 0 ? {} : { agentType: terminal.costAttribution.agentType },
 			...terminal === void 0 ? {} : { status: terminal.status },
 			...terminal?.evidence === void 0 ? {} : { evidence: { ...terminal.evidence } }
@@ -9071,455 +9091,1021 @@ async function reconcileRunMeta(store, runId, opts) {
 	};
 }
 //#endregion
-//#region src/stores/jsonl.ts
-/**
-* JsonlFileStore (M2-T01): the durable file store. One JSON entry per
-* line per run; the journal doubles as an event log. Meta records live
-* beside the journal and are replaced atomically, so listRuns never
-* parses payloads.
-*
-* Contract (DEF-4 tightening):
-* - A1 atomicity: a torn trailing line (crash mid-append) is never
-*   visible in load; the incomplete fragment is dropped and overwritten
-*   by the next append. Whole records on that line are data, never
-*   fragment (RV701): a crash that persisted every JSON byte but not
-*   the '\n' leaves a parseable tail that load serves and append
-*   terminates before writing, and repair salvages complete records a
-*   glued line carries instead of discarding the line, so an entry a
-*   load has served can never be un-served by a later repair.
-* - A2 total per-run order: load returns append order, stable across
-*   calls (the kernel's per-run queue serializes appends).
-* - A3 read-your-writes: append resolves after the line is written.
-* - A4 opaque payload: entries round-trip byte-for-byte as JSON; unknown
-*   kinds and fields pass through untouched.
-*
-* Leasing is NOT implemented here: LeasableStore ships with
-* @rulvar/store-sqlite (M5); JsonlFileStore is single-writer by
-* convention.
-*/
-const JOURNAL_SUFFIX = ".jsonl";
-const META_SUFFIX = ".meta.json";
-function safeName(runId) {
-	if (!/^[A-Za-z0-9._-]+$/.test(runId)) throw new JournalOrderViolation(`JsonlFileStore: runId '${runId}' is not filesystem-safe ([A-Za-z0-9._-] only)`);
-	return runId;
-}
+//#region src/l0/telemetry-reduce.ts
+const ZERO = {
+	inputTokens: 0,
+	outputTokens: 0,
+	cacheReadTokens: 0,
+	cacheWriteTokens: 0
+};
 /**
-* Whole JSON values glued on one line, split apart without parser
-* ambiguity (RV701): depth is tracked outside string literals only, and
-* every candidate must still round-trip JSON.parse. A line that is not a
-* clean concatenation from its first byte salvages its whole prefix
-* values and returns everything after them as the torn fragment, so the
-* caller keeps accepted records and drops exactly the unacknowledged
-* tail a crash tore.
+* Reduces one run's event stream (or any slice of it) to the invocation
+* table. Feed it the events in emission order; both a live stream and a
+* replayed one produce the same usage and cost columns.
 */
-function splitConcatenatedJson(line) {
-	const whole = [];
-	let start = 0;
-	let depth = 0;
-	let inString = false;
-	let escaped = false;
-	for (let i = 0; i < line.length; i += 1) {
-		const ch = line[i];
-		if (inString) {
-			if (escaped) escaped = false;
-			else if (ch === "\\") escaped = true;
-			else if (ch === "\"") inString = false;
-			continue;
-		}
-		if (ch === "\"") {
-			inString = true;
-			continue;
+function reduceInvocationTable(events) {
+	const rows = /* @__PURE__ */ new Map();
+	const order = [];
+	const openPhases = /* @__PURE__ */ new Map();
+	const byRole = {};
+	let totalCostUsd = 0;
+	const rowFor = (event) => {
+		let row = rows.get(event.spanId);
+		if (row === void 0) {
+			row = {
+				spanId: event.spanId,
+				agentType: event.agentType,
+				...event.label === void 0 ? {} : { label: event.label },
+				usage: ZERO,
+				costUsd: 0,
+				costBasis: "aggregate-estimate",
+				usageApprox: false,
+				retryCount: 0,
+				replayed: event.replayed === true,
+				open: true,
+				phases: []
+			};
+			rows.set(event.spanId, row);
+			order.push(row);
 		}
-		if (ch === "{" || ch === "[") {
-			depth += 1;
-			continue;
+		return row;
+	};
+	for (const event of events) switch (event.type) {
+		case "agent:start": {
+			const row = rowFor(event);
+			row.role = event.role;
+			break;
 		}
-		if (ch === "}" || ch === "]") {
-			depth -= 1;
-			if (depth < 0) return {
-				whole,
-				fragment: line.slice(start)
+		case "agent:phase:start": {
+			const row = rowFor(event);
+			const phase = {
+				invocation: event.invocation,
+				role: event.role,
+				model: event.model,
+				durationMs: 0,
+				usage: ZERO,
+				costUsd: 0,
+				costBasis: "aggregate-estimate",
+				retries: 0,
+				replayed: event.replayed === true,
+				open: true
 			};
-			if (depth === 0) {
-				const candidate = line.slice(start, i + 1);
-				try {
-					whole.push(JSON.parse(candidate));
-				} catch {
-					return {
-						whole,
-						fragment: line.slice(start)
-					};
-				}
-				start = i + 1;
+			row.phases.push(phase);
+			openPhases.set(`${event.spanId}#${event.invocation}`, phase);
+			break;
+		}
+		case "agent:phase:end": {
+			const key = `${event.spanId}#${event.invocation}`;
+			let phase = openPhases.get(key);
+			if (phase === void 0) {
+				phase = {
+					invocation: event.invocation,
+					role: event.role,
+					model: event.model,
+					durationMs: 0,
+					usage: ZERO,
+					costUsd: 0,
+					costBasis: "aggregate-estimate",
+					retries: 0,
+					replayed: event.replayed === true,
+					open: true
+				};
+				rowFor(event).phases.push(phase);
 			}
+			openPhases.delete(key);
+			phase.open = false;
+			phase.role = event.role;
+			phase.model = event.model;
+			phase.durationMs = event.durationMs;
+			phase.usage = event.usage;
+			phase.costUsd = event.costUsd;
+			phase.costBasis = event.costBasis ?? "aggregate-estimate";
+			phase.outcome = event.outcome;
+			phase.retries = event.retries ?? 0;
+			const bucket = byRole[event.role] ??= {
+				usage: ZERO,
+				costUsd: 0,
+				costBasis: "per-call"
+			};
+			bucket.usage = sumUsage(bucket.usage, event.usage);
+			bucket.costUsd += event.costUsd;
+			if (phase.costBasis === "aggregate-estimate") bucket.costBasis = "aggregate-estimate";
+			break;
+		}
+		case "agent:end": {
+			const row = rowFor(event);
+			row.open = false;
+			row.status = event.status;
+			row.usage = event.usage;
+			row.costUsd = event.costUsd;
+			row.costBasis = event.costBasis ?? "aggregate-estimate";
+			row.usageApprox = event.usageApprox === true;
+			row.retryCount = event.retryCount ?? 0;
+			if (event.toolBudget !== void 0) row.toolBudget = event.toolBudget;
+			totalCostUsd += event.costUsd;
+			break;
 		}
+		default: break;
 	}
 	return {
-		whole,
-		fragment: line.slice(start)
+		agents: order,
+		byRole,
+		totalCostUsd
 	};
 }
-var JsonlFileStore = class {
-	dir;
-	/**
-	* The stored tail seq per run, lazily initialized from the file on the
-	* first append this instance performs (obligation A5). Per instance by
-	* design: cross-process writers are the lease seam's job.
-	*/
-	lastSeq = /* @__PURE__ */ new Map();
-	/**
-	* The verify-only load switch (RV1512): with `repairOnLoad: false`,
-	* `load` serves the salvageable records WITHOUT rewriting the file,
-	* so an auditor's "verification" read never destroys the evidence
-	* of a tear it found. The default keeps the owner semantics byte
-	* for byte: a torn tail repairs on load exactly as documented in
-	* the A1 model above. Mutations (`append`, `putMeta`, `delete`)
-	* are unaffected by the flag; an auditor that must not write simply
-	* does not call them.
-	*/
-	repairOnLoad;
-	constructor(options) {
-		this.dir = options.dir;
-		this.repairOnLoad = options.repairOnLoad !== false;
-		mkdirSync(this.dir, { recursive: true });
-	}
-	journalPath(runId) {
-		return join(this.dir, `${safeName(runId)}${JOURNAL_SUFFIX}`);
-	}
-	metaPath(runId) {
-		return join(this.dir, `${safeName(runId)}${META_SUFFIX}`);
-	}
-	async append(runId, e) {
-		let tail = this.lastSeq.get(runId);
-		if (tail === void 0) {
-			const existing = await this.load(runId);
-			this.terminateUnterminatedTail(runId);
-			const last = existing[existing.length - 1];
-			tail = last !== void 0 && Number.isFinite(last.seq) ? last.seq : Number.NEGATIVE_INFINITY;
-			this.lastSeq.set(runId, tail);
-		}
-		if (Number.isFinite(e.seq) && e.seq <= tail) throw new JournalOrderViolation(`JsonlFileStore: append of seq ${e.seq} to run '${runId}' is not after the stored tail seq ${tail}; a concurrent writer raced this journal from a stale tail`);
-		appendFileSync(this.journalPath(runId), `${JSON.stringify(e)}\n`, "utf8");
-		if (Number.isFinite(e.seq)) this.lastSeq.set(runId, e.seq);
-	}
-	async load(runId) {
-		let raw;
-		try {
-			raw = readFileSync(this.journalPath(runId), "utf8");
-		} catch (thrown) {
-			if (thrown.code === "ENOENT") return [];
-			throw thrown;
-		}
-		const lines = raw.split("\n");
-		const entries = [];
-		for (let i = 0; i < lines.length; i += 1) {
-			const line = lines[i] ?? "";
-			if (line === "") continue;
-			try {
-				entries.push(JSON.parse(line));
-			} catch (thrown) {
-				if (lines.slice(i + 1).every((rest) => rest === "")) {
-					for (const value of splitConcatenatedJson(line).whole) entries.push(value);
-					if (this.repairOnLoad) this.repairTornTail(runId, entries);
-					break;
-				}
-				throw new JournalOrderViolation(`JsonlFileStore: corrupt journal line ${i + 1} of run '${runId}' (not the trailing line, so this is not a torn append)`, { cause: thrown });
-			}
-		}
-		return entries;
-	}
-	/**
-	* Restores the trailing '\n' of a parseable-but-unterminated tail
-	* (RV701). One byte appended in place terminates the record exactly
-	* where the crash left it; the file's bytes before it stay untouched.
-	* No-op on a missing, empty, or already-terminated journal.
-	*/
-	terminateUnterminatedTail(runId) {
-		const path = this.journalPath(runId);
-		let fd;
-		try {
-			fd = openSync(path, "r");
-		} catch (thrown) {
-			if (thrown.code === "ENOENT") return;
-			throw thrown;
-		}
-		let needsNewline = false;
-		try {
-			const size = fstatSync(fd).size;
-			if (size > 0) {
-				const lastByte = /* @__PURE__ */ new Uint8Array(1);
-				readSync(fd, lastByte, 0, 1, size - 1);
-				needsNewline = lastByte[0] !== 10;
+/**
+* The label the claim-consistency judge invocation dispatches under
+* (RV1502; named here since RV1604 so the critical-path reducer and the
+* orchestrator share one constant): the judge rides role 'synthesize',
+* and this label is what tells its wall apart from a real final
+* composition in {@link reduceCriticalPath}.
+*/
+const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
+/**
+* The label the final synthesis (composition) invocation dispatches
+* under (RV2901). The engine labelling its OWN dispatches is what lets
+* `criticalPathFromJournal` split the synthesize bucket offline: the
+* split demands a label on EVERY synthesize span, and the comparison
+* run that shipped the journal fold still refused it because this one
+* dispatch stayed anonymous while the claim judge was labelled.
+*/
+const FINAL_COMPOSITION_LABEL = "final-composition";
+/**
+* The label an incremental synthesis note dispatches under (RV2901).
+* Notes ride role 'synthesize' and are composition-side work, so both
+* reducers count them toward the composition half of the split; the
+* label exists so a journal reader can tell WHICH composition spans
+* were notes without guessing from their size.
+*/
+const SYNTHESIS_NOTE_LABEL = "synthesis-note";
+/** Total length of the union of possibly overlapping intervals. */
+function unionLength(intervals) {
+	const positive = intervals.filter((interval) => interval.to > interval.from);
+	if (positive.length === 0) return 0;
+	const sorted = [...positive].sort((a, b) => a.from - b.from);
+	let total = 0;
+	let from = sorted[0]?.from ?? 0;
+	let to = sorted[0]?.to ?? 0;
+	for (const interval of sorted.slice(1)) if (interval.from > to) {
+		total += to - from;
+		from = interval.from;
+		to = interval.to;
+	} else if (interval.to > to) to = interval.to;
+	return total + (to - from);
+}
+function reduceCriticalPath(events) {
+	let runStart;
+	let runEnd;
+	const startBySpan = /* @__PURE__ */ new Map();
+	let lastWorkerEnd;
+	let workerSpans = 0;
+	let synthesisMs = 0;
+	let finalCompositionMs = 0;
+	let semanticJudgeMs = 0;
+	const coordinationModel = [];
+	const coordinationTools = [];
+	const synthesisSpans = [];
+	const spanOf = (durationMs) => Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
+	for (const event of events) {
+		const at = Date.parse(event.ts);
+		if (!Number.isFinite(at)) continue;
+		switch (event.type) {
+			case "run:start":
+				runStart ??= at;
+				break;
+			case "run:end":
+				runEnd = at;
+				break;
+			case "agent:start":
+				startBySpan.set(event.spanId, {
+					role: event.role,
+					at,
+					...event.label === void 0 ? {} : { label: event.label }
+				});
+				break;
+			case "agent:phase:end":
+				if (startBySpan.get(event.spanId)?.role === "orchestrate") coordinationModel.push({
+					phase: event.role,
+					from: at - spanOf(event.durationMs),
+					to: at
+				});
+				break;
+			case "tool:end":
+				if (startBySpan.get(event.spanId)?.role === "orchestrate") coordinationTools.push({
+					name: event.toolName,
+					from: at - spanOf(event.durationMs),
+					to: at
+				});
+				break;
+			case "agent:end": {
+				const started = startBySpan.get(event.spanId);
+				if (started === void 0) break;
+				if (started.role === "synthesize") {
+					const wall = Math.max(0, at - started.at);
+					const judge = started.label === CLAIM_JUDGE_LABEL;
+					synthesisMs += wall;
+					if (judge) semanticJudgeMs += wall;
+					else finalCompositionMs += wall;
+					synthesisSpans.push({
+						from: started.at,
+						to: at,
+						judge
+					});
+				} else if (started.role !== "orchestrate") {
+					workerSpans += 1;
+					lastWorkerEnd = lastWorkerEnd === void 0 ? at : Math.max(lastWorkerEnd, at);
+				}
+				break;
 			}
-		} finally {
-			closeSync(fd);
+			default: break;
 		}
-		if (needsNewline) appendFileSync(path, "\n", "utf8");
-	}
-	repairTornTail(runId, whole) {
-		const path = this.journalPath(runId);
-		const temp = `${path}.tmp`;
-		writeFileSync(temp, whole.map((entry) => JSON.stringify(entry)).join("\n") + (whole.length > 0 ? "\n" : ""), "utf8");
-		renameSync(temp, path);
-	}
-	async putMeta(m) {
-		const path = this.metaPath(m.runId);
-		const temp = `${path}.tmp`;
-		writeFileSync(temp, JSON.stringify(m, null, 2), "utf8");
-		renameSync(temp, path);
 	}
-	async getMeta(runId) {
-		try {
-			return JSON.parse(readFileSync(this.metaPath(runId), "utf8"));
-		} catch {
-			return;
+	const path = {
+		synthesisMs,
+		finalCompositionMs,
+		semanticJudgeMs,
+		workerSpans
+	};
+	if (runStart !== void 0 && runEnd !== void 0) path.runWallMs = Math.max(0, runEnd - runStart);
+	if (runEnd !== void 0 && lastWorkerEnd !== void 0) {
+		path.postFanInMs = Math.max(0, runEnd - lastWorkerEnd);
+		const windowFrom = Math.min(lastWorkerEnd, runEnd);
+		const windowTo = runEnd;
+		const clip = (interval) => {
+			if (interval.to < windowFrom || interval.from > windowTo) return;
+			return {
+				from: Math.max(interval.from, windowFrom),
+				to: Math.min(interval.to, windowTo)
+			};
+		};
+		const byPhase = {};
+		const modelClipped = [];
+		for (const interval of coordinationModel) {
+			const clipped = clip(interval);
+			if (clipped === void 0) continue;
+			byPhase[interval.phase] = (byPhase[interval.phase] ?? 0) + (clipped.to - clipped.from);
+			modelClipped.push(clipped);
 		}
-	}
-	async listRuns(f) {
-		const metas = [];
-		for (const file of readdirSync(this.dir)) {
-			if (!file.endsWith(META_SUFFIX)) continue;
-			try {
-				metas.push(JSON.parse(readFileSync(join(this.dir, file), "utf8")));
-			} catch {}
+		const synthesisClipped = [];
+		let judgeClippedMs = 0;
+		let compositionClippedMs = 0;
+		for (const span of synthesisSpans) {
+			const clipped = clip(span);
+			if (clipped === void 0) continue;
+			synthesisClipped.push(clipped);
+			if (span.judge) judgeClippedMs += clipped.to - clipped.from;
+			else compositionClippedMs += clipped.to - clipped.from;
 		}
-		return metas.filter((meta) => metaMatchesFilter(meta, f));
+		const byName = {};
+		const callsByName = {};
+		const toolsClipped = [];
+		for (const interval of coordinationTools) {
+			const clipped = clip(interval);
+			if (clipped === void 0) continue;
+			byName[interval.name] = (byName[interval.name] ?? 0) + (clipped.to - clipped.from);
+			callsByName[interval.name] = (callsByName[interval.name] ?? 0) + 1;
+			toolsClipped.push(clipped);
+		}
+		const lengthOf = (intervals) => intervals.reduce((sum, interval) => sum + (interval.to - interval.from), 0);
+		const coveredMs = unionLength([
+			...modelClipped,
+			...toolsClipped,
+			...synthesisClipped
+		]);
+		const modelOnlyMs = unionLength([...modelClipped, ...toolsClipped]) - unionLength(toolsClipped);
+		const breakdown = {
+			coordinationModelMs: lengthOf(modelClipped),
+			coordinationModelMsByPhase: byPhase,
+			coordinationModelOnlyMs: modelOnlyMs,
+			coordinationToolMs: lengthOf(toolsClipped),
+			coordinationToolMsByName: byName,
+			coordinationToolCallsByName: callsByName,
+			synthesisMs: lengthOf(synthesisClipped),
+			finalCompositionMs: compositionClippedMs,
+			semanticJudgeMs: judgeClippedMs,
+			coveredMs,
+			residueMs: Math.max(0, path.postFanInMs - coveredMs)
+		};
+		if (path.postFanInMs > 0) breakdown.residueShare = breakdown.residueMs / path.postFanInMs;
+		path.postFanIn = breakdown;
 	}
-	async delete(runId) {
-		rmSync(this.journalPath(runId), { force: true });
-		rmSync(this.metaPath(runId), { force: true });
-		this.lastSeq.delete(runId);
+	if (path.runWallMs !== void 0 && path.runWallMs > 0) {
+		if (path.postFanInMs !== void 0) path.postFanInShare = path.postFanInMs / path.runWallMs;
+		path.synthesisShare = synthesisMs / path.runWallMs;
 	}
+	return path;
+}
+//#endregion
+//#region src/stores/critical-path.ts
+const parse$1 = (at) => {
+	if (at === void 0) return;
+	const ms = Date.parse(at);
+	return Number.isFinite(ms) ? ms : void 0;
 };
-const TRANSCRIPT_SUFFIX = ".bin";
 /**
-* File-backed TranscriptStore (M6-T02): blobs (transcripts, checkpoints,
-* persisted CompiledWorkflow sources) as one file per ref under `dir`,
-* so compiled runs resume across processes. Refs follow the
-* `<runId>/<name>` convention; nested segments become directories.
+* Fold a run's critical path out of its journal.
 *
-* Every ref is contained under `dir` (v1.36.0 review SEC-P1): each
-* segment must match `[A-Za-z0-9._-]` and be neither empty, '.', nor
-* '..', and the resolved path must stay under the resolved root. A '..'
-* segment used to pass the per-segment alphabet (dots are in it) and, via
-* `join`, escape the root; a caller passing an untrusted ref (or an
-* untrusted runId, which prefixes checkpoint and workflow-source refs)
-* could read, write, or delete `.bin` files outside `dir`.
+* @param entries the journal of one run, in any order
 */
-var FileTranscriptStore = class {
-	dir;
-	constructor(options) {
-		this.dir = options.dir;
-		mkdirSync(this.dir, { recursive: true });
+function criticalPathFromJournal(entries) {
+	const ordered = [...entries].sort((a, b) => a.seq - b.seq);
+	let runStart;
+	let runEnd;
+	let lastWorkerEnd;
+	let workerSpans = 0;
+	let unclassifiedSpans = 0;
+	let synthesisMs = 0;
+	let finalCompositionMs = 0;
+	let semanticJudgeMs = 0;
+	let labelledSynthesis = false;
+	let unlabelledSynthesis = false;
+	for (const entry of ordered) {
+		const startedAt = parse$1(entry.startedAt);
+		const endedAt = parse$1(entry.endedAt);
+		if (startedAt !== void 0) runStart = runStart === void 0 ? startedAt : Math.min(runStart, startedAt);
+		const last = endedAt ?? startedAt;
+		if (last !== void 0) runEnd = runEnd === void 0 ? last : Math.max(runEnd, last);
+		if (entry.kind !== "agent" || entry.status === "running" || entry.status === "suspended") continue;
+		const role = entry.costAttribution?.role;
+		if (role === void 0) {
+			unclassifiedSpans += 1;
+			continue;
+		}
+		if (role === "orchestrate") continue;
+		if (role !== "synthesize") {
+			workerSpans += 1;
+			if (endedAt !== void 0) lastWorkerEnd = lastWorkerEnd === void 0 ? endedAt : Math.max(lastWorkerEnd, endedAt);
+			continue;
+		}
+		if (startedAt === void 0 || endedAt === void 0) continue;
+		const wall = Math.max(0, endedAt - startedAt);
+		synthesisMs += wall;
+		const label = entry.costAttribution?.label;
+		if (label === void 0) {
+			unlabelledSynthesis = true;
+			continue;
+		}
+		labelledSynthesis = true;
+		if (label === "claim-consistency-judge" || label.startsWith(`claim-consistency-judge-`)) semanticJudgeMs += wall;
+		else finalCompositionMs += wall;
 	}
-	blobPath(ref) {
-		const segments = ref.split("/");
-		for (const segment of segments) if (segment === "" || segment === "." || segment === ".." || !/^[A-Za-z0-9._-]+$/.test(segment)) throw new JournalOrderViolation(`FileTranscriptStore: ref segment '${segment}' is not filesystem-safe`);
-		const name = segments.pop() ?? "";
-		const path = join(this.dir, ...segments, `${name}${TRANSCRIPT_SUFFIX}`);
-		const root = resolve(this.dir);
-		const resolved = resolve(path);
-		if (resolved !== root && !resolved.startsWith(`${root}${sep}`)) throw new JournalOrderViolation(`FileTranscriptStore: ref '${ref}' resolves outside the configured root`);
-		return path;
+	const segments = logicalRunTelemetry(ordered).segments;
+	const path = {
+		workerSpans,
+		synthesisMs,
+		unclassifiedSpans,
+		segments
+	};
+	if (labelledSynthesis && !unlabelledSynthesis) {
+		path.finalCompositionMs = finalCompositionMs;
+		path.semanticJudgeMs = semanticJudgeMs;
+	}
+	if (segments > 1 || runStart === void 0 || runEnd === void 0) return path;
+	path.runWallMs = Math.max(0, runEnd - runStart);
+	if (lastWorkerEnd !== void 0) path.postFanInMs = Math.max(0, runEnd - lastWorkerEnd);
+	if (path.runWallMs > 0) {
+		if (path.postFanInMs !== void 0) path.postFanInShare = path.postFanInMs / path.runWallMs;
+		path.synthesisShare = synthesisMs / path.runWallMs;
 	}
-	async put(ref, blob) {
-		const path = this.blobPath(ref);
-		mkdirSync(dirname(path), { recursive: true });
-		const temp = `${path}.tmp`;
-		writeFileSync(temp, blob);
-		renameSync(temp, path);
+	return path;
+}
+//#endregion
+//#region src/stores/synthesis-candidates.ts
+const parse = (at) => {
+	if (at === void 0) return;
+	const ms = Date.parse(at);
+	return Number.isFinite(ms) ? ms : void 0;
+};
+const VERDICTS = /* @__PURE__ */ new Set([
+	"accepted",
+	"repair",
+	"rejected"
+]);
+const OPTIONAL_USAGE_KEYS = [
+	"reasoningTokens",
+	"cacheWrite5mTokens",
+	"cacheWrite1hTokens"
+];
+function sumUsage$1(rows) {
+	const total = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0
+	};
+	for (const row of rows) {
+		if (row.usage === void 0) continue;
+		total.inputTokens += row.usage.inputTokens;
+		total.outputTokens += row.usage.outputTokens;
+		total.cacheReadTokens += row.usage.cacheReadTokens;
+		total.cacheWriteTokens += row.usage.cacheWriteTokens;
+		for (const key of OPTIONAL_USAGE_KEYS) {
+			const share = row.usage[key];
+			if (share !== void 0) total[key] = (total[key] ?? 0) + share;
+		}
+	}
+	return total;
+}
+const usageUnknown = (row) => {
+	if (row.outcome === "ok") return false;
+	const usage = row.usage;
+	if (usage === void 0) return true;
+	return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.cacheReadTokens === 0 && usage.cacheWriteTokens === 0 && (usage.reasoningTokens ?? 0) === 0;
+};
+/**
+* Fold the finish candidates (RV2902) out of a run's journal: each
+* journaled validation verdict with the window of wall, wires, usage,
+* and priced cost that produced the candidate it judged.
+*
+* @param entries the journal of one run, in any order
+* @param priceUsd prices one call's usage at its serving model, the
+*   same shape `invoiceFromJournal` takes; omit to fold without money
+*/
+function synthesisCandidatesFromJournal(entries, priceUsd) {
+	const ordered = [...entries].sort((a, b) => a.seq - b.seq);
+	const spans = [];
+	for (const entry of ordered) {
+		if (entry.kind !== "agent" || entry.status === "running" || entry.status === "suspended" || entry.costAttribution?.role !== "synthesize" || typeof entry.ref !== "number") continue;
+		spans.push({
+			runningSeq: entry.ref,
+			terminalSeq: entry.seq,
+			startedAt: parse(entry.startedAt),
+			...entry.costAttribution.label === void 0 ? {} : { label: entry.costAttribution.label },
+			records: entry.providerCalls,
+			wires: [],
+			verdictSeqs: []
+		});
 	}
-	async get(ref) {
-		try {
-			return new Uint8Array(readFileSync(this.blobPath(ref)));
-		} catch (error) {
-			if (error.code === "ENOENT") return null;
-			throw error;
+	const bySeqOpen = /* @__PURE__ */ new Map();
+	for (const span of spans) bySeqOpen.set(span.runningSeq, span);
+	const verdicts = [];
+	for (const entry of ordered) {
+		if (entry.kind !== "decision") continue;
+		const value = entry.value;
+		if (value === void 0) continue;
+		if (value.decisionType === "provider-call") {
+			const wire = value;
+			if (typeof wire.agentRef !== "number") continue;
+			const span = bySeqOpen.get(wire.agentRef);
+			const record = wire.record;
+			if (span === void 0 || record === void 0 || typeof record.ordinal !== "number") continue;
+			span.wires.push({
+				seq: entry.seq,
+				ordinal: record.ordinal,
+				...typeof record.servedBy === "string" ? { servedBy: record.servedBy } : {},
+				outcome: typeof record.outcome === "string" ? record.outcome : "ok",
+				...record.usage === void 0 ? {} : { usage: record.usage },
+				wireRequests: typeof record.wireRequests === "number" ? record.wireRequests : 1
+			});
+			continue;
+		}
+		if (value.decisionType !== "orchestrator_finish_validation") continue;
+		const verdictValue = value;
+		if (typeof verdictValue.verdict !== "string" || !VERDICTS.has(verdictValue.verdict)) continue;
+		let host;
+		for (const span of spans) if (entry.seq > span.runningSeq && entry.seq < span.terminalSeq) {
+			if (host === void 0 || span.runningSeq > host.runningSeq) host = span;
 		}
+		if (host !== void 0) host.verdictSeqs.push(entry.seq);
+		verdicts.push({
+			seq: entry.seq,
+			...entry.startedAt === void 0 ? {} : { at: entry.startedAt },
+			value: verdictValue,
+			...host === void 0 ? {} : { span: host }
+		});
 	}
-	async list(runId) {
-		if (runId === "." || runId === "..") throw new JournalOrderViolation(`FileTranscriptStore: runId '${runId}' is not filesystem-safe`);
-		const root = join(this.dir, safeName(runId));
-		const refs = [];
-		const walk = (dir, prefix) => {
-			let names;
-			try {
-				names = readdirSync(dir);
-			} catch {
-				return;
-			}
-			for (const name of names) {
-				const path = join(dir, name);
-				if (statSync(path).isDirectory()) walk(path, `${prefix}${name}/`);
-				else if (name.endsWith(TRANSCRIPT_SUFFIX)) refs.push(`${prefix}${name.slice(0, -4)}`);
-			}
-		};
-		walk(root, `${runId}/`);
-		return refs.sort();
+	const attributable = /* @__PURE__ */ new Set();
+	let unattributedSpans = 0;
+	for (const span of spans) {
+		const recorded = (span.records ?? []).map((record) => record.ordinal).sort((a, b) => a - b);
+		const rows = [...span.wires].map((wire) => wire.ordinal).sort((a, b) => a - b);
+		if (span.records !== void 0 && recorded.length === rows.length && recorded.every((ordinal, index) => ordinal === rows[index])) attributable.add(span);
+		else unattributedSpans += 1;
+	}
+	let tailWires = 0;
+	for (const span of spans) {
+		if (!attributable.has(span)) continue;
+		const lastVerdict = span.verdictSeqs.length === 0 ? void 0 : Math.max(...span.verdictSeqs);
+		if (lastVerdict === void 0) continue;
+		for (const wire of span.wires) if (wire.seq > lastVerdict) tailWires += wire.wireRequests;
 	}
-	async delete(ref) {
-		try {
-			rmSync(this.blobPath(ref));
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
+	const candidates = [];
+	let unhostedVerdicts = 0;
+	const previousBoundary = /* @__PURE__ */ new Map();
+	for (const verdict of verdicts) {
+		const value = verdict.value;
+		if (verdict.span === void 0) {
+			unhostedVerdicts += 1;
+			continue;
 		}
+		const span = verdict.span;
+		const boundary = previousBoundary.get(span) ?? {
+			seq: span.runningSeq,
+			...span.startedAt === void 0 ? {} : { at: span.startedAt }
+		};
+		const verdictAtMs = parse(verdict.at);
+		previousBoundary.set(span, {
+			seq: verdict.seq,
+			...verdictAtMs === void 0 ? {} : { at: verdictAtMs }
+		});
+		const candidate = {
+			verdict: value.verdict,
+			verdictSeq: verdict.seq,
+			...verdict.at === void 0 ? {} : { verdictAt: verdict.at },
+			...typeof value.callId === "string" ? { callId: value.callId } : {},
+			...typeof value.repairsUsed === "number" ? { repairsUsed: value.repairsUsed } : {},
+			...typeof value.maxRepairs === "number" ? { maxRepairs: value.maxRepairs } : {},
+			...typeof value.contractHash === "string" ? { contractHash: value.contractHash } : {},
+			...typeof value.candidateHash === "string" ? { candidateHash: value.candidateHash } : {},
+			...typeof value.candidateChars === "number" ? { candidateChars: value.candidateChars } : {},
+			...typeof value.candidateRef === "string" ? { candidateRef: value.candidateRef } : {},
+			failed: Array.isArray(value.failed) ? value.failed.filter((failure) => typeof failure.name === "string").map((failure) => ({
+				name: failure.name,
+				reasons: Array.isArray(failure.reasons) ? failure.reasons.filter((reason) => typeof reason === "string") : []
+			})) : [],
+			...span.label === void 0 ? {} : { spanLabel: span.label }
+		};
+		if (boundary.at !== void 0 && verdictAtMs !== void 0) candidate.windowMs = Math.max(0, verdictAtMs - boundary.at);
+		if (attributable.has(span)) {
+			const window = span.wires.filter((wire) => wire.seq > boundary.seq && wire.seq < verdict.seq);
+			candidate.wires = window.reduce((sum, wire) => sum + wire.wireRequests, 0);
+			candidate.usage = sumUsage$1(window);
+			const unknown = window.filter((wire) => usageUnknown(wire)).length;
+			if (unknown > 0) candidate.usageUnknownWires = unknown;
+			if (priceUsd !== void 0) {
+				let priced = 0;
+				let complete = true;
+				for (const wire of window) {
+					const usd = wire.servedBy === void 0 || wire.usage === void 0 ? void 0 : priceUsd(wire.servedBy, wire.usage);
+					if (usd === void 0) {
+						complete = false;
+						break;
+					}
+					priced += usd;
+				}
+				if (complete) candidate.costUsd = priced;
+			}
+		}
+		candidates.push(candidate);
 	}
-};
+	return {
+		candidates,
+		synthesisSpans: spans.length,
+		unhostedVerdicts,
+		unattributedSpans,
+		tailWires
+	};
+}
 //#endregion
-//#region src/model/pricing.ts
+//#region src/stores/jsonl.ts
 /**
-* Resolves the pricing for a model: the versioned table wins; the
-* adapter-reported caps.pricing is the fallback; undefined means
-* unpriced (the CostReport surfaces it, never a silent zero).
+* JsonlFileStore (M2-T01): the durable file store. One JSON entry per
+* line per run; the journal doubles as an event log. Meta records live
+* beside the journal and are replaced atomically, so listRuns never
+* parses payloads.
+*
+* Contract (DEF-4 tightening):
+* - A1 atomicity: a torn trailing line (crash mid-append) is never
+*   visible in load; the incomplete fragment is dropped and overwritten
+*   by the next append. Whole records on that line are data, never
+*   fragment (RV701): a crash that persisted every JSON byte but not
+*   the '\n' leaves a parseable tail that load serves and append
+*   terminates before writing, and repair salvages complete records a
+*   glued line carries instead of discarding the line, so an entry a
+*   load has served can never be un-served by a later repair.
+* - A2 total per-run order: load returns append order, stable across
+*   calls (the kernel's per-run queue serializes appends).
+* - A3 read-your-writes: append resolves after the line is written.
+* - A4 opaque payload: entries round-trip byte-for-byte as JSON; unknown
+*   kinds and fields pass through untouched.
+*
+* Leasing is NOT implemented here: LeasableStore ships with
+* @rulvar/store-sqlite (M5); JsonlFileStore is single-writer by
+* convention.
 */
-function resolvePricing(ref, table, capsPricing) {
-	return table?.models[ref] ?? capsPricing;
-}
-/** The tier a full prompt lands in: the highest threshold strictly below it. */
-function tierFor(pricing, inputTokens) {
-	let tier;
-	for (const candidate of pricing.tiers ?? []) if (inputTokens > candidate.aboveInputTokens && (tier === void 0 || candidate.aboveInputTokens > tier.aboveInputTokens)) tier = candidate;
-	return tier;
+const JOURNAL_SUFFIX = ".jsonl";
+const META_SUFFIX = ".meta.json";
+function safeName(runId) {
+	if (!/^[A-Za-z0-9._-]+$/.test(runId)) throw new JournalOrderViolation(`JsonlFileStore: runId '${runId}' is not filesystem-safe ([A-Za-z0-9._-] only)`);
+	return runId;
 }
 /**
-* Decomposes one usage against one pricing row into the four billing
-* components. Under the Usage invariant inputTokens is the FULL prompt
-* including cache reads and writes, so the input rate bills only the
-* uncached remainder and cache tokens bill at their own rates, never
-* twice; a row that omits a cache rate bills those tokens at the plain
-* input rate rather than silently for free. A row may carry
-* long-context tiers: the highest threshold strictly below the full
-* prompt re-prices the ENTIRE request (input-side rates scale by
-* inputMultiplier, the output rate by outputMultiplier). Cache writes
-* price at the 5m premium rate by default; when the usage carries the
-* TTL split (RV810: `cacheWrite5mTokens` and `cacheWrite1hTokens`,
-* filled by adapters whose provider distinguishes write TTLs), the 1h
-* share prices at `cacheWrite1hUsdPerMTok` (falling back to the plain
-* write rate when the row lacks it) and everything the 1h share does
-* not claim, the 5m share plus any unattributed remainder an upstream
-* invariant violation left, bills at the write rate, never silently
-* for free. The component's `tokens` stays the WHOLE
-* `cacheWriteTokens` either way, so statement reconciliation keys are
-* unchanged.
+* Whole JSON values glued on one line, split apart without parser
+* ambiguity (RV701): depth is tracked outside string literals only, and
+* every candidate must still round-trip JSON.parse. A line that is not a
+* clean concatenation from its first byte salvages its whole prefix
+* values and returns everything after them as the torn fragment, so the
+* caller keeps accepted records and drops exactly the unacknowledged
+* tail a crash tore.
 */
-function priceComponentsOf(pricing, usage) {
-	const tier = tierFor(pricing, usage.inputTokens);
-	const inputMul = tier?.inputMultiplier ?? 1;
-	const outputMul = tier?.outputMultiplier ?? 1;
-	const uncachedInputTokens = Math.max(0, usage.inputTokens - usage.cacheReadTokens - usage.cacheWriteTokens);
-	const writeRate = pricing.cacheWriteUsdPerMTok ?? pricing.inputUsdPerMTok;
-	const write1hRate = pricing.cacheWrite1hUsdPerMTok ?? writeRate;
-	const write1hTokens = usage.cacheWrite5mTokens !== void 0 || usage.cacheWrite1hTokens !== void 0 ? usage.cacheWrite1hTokens ?? 0 : 0;
-	const writeDefaultTokens = Math.max(0, usage.cacheWriteTokens - write1hTokens);
-	return {
-		input: {
-			tokens: uncachedInputTokens,
-			usd: uncachedInputTokens / 1e6 * pricing.inputUsdPerMTok * inputMul
-		},
-		output: {
-			tokens: usage.outputTokens,
-			usd: usage.outputTokens / 1e6 * pricing.outputUsdPerMTok * outputMul
-		},
-		cachedInput: {
-			tokens: usage.cacheReadTokens,
-			usd: usage.cacheReadTokens / 1e6 * (pricing.cacheReadUsdPerMTok ?? pricing.inputUsdPerMTok) * inputMul
-		},
-		cacheWrite: {
-			tokens: usage.cacheWriteTokens,
-			usd: (writeDefaultTokens / 1e6 * writeRate + write1hTokens / 1e6 * write1hRate) * inputMul
+function splitConcatenatedJson(line) {
+	const whole = [];
+	let start = 0;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let i = 0; i < line.length; i += 1) {
+		const ch = line[i];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			continue;
+		}
+		if (ch === "{" || ch === "[") {
+			depth += 1;
+			continue;
+		}
+		if (ch === "}" || ch === "]") {
+			depth -= 1;
+			if (depth < 0) return {
+				whole,
+				fragment: line.slice(start)
+			};
+			if (depth === 0) {
+				const candidate = line.slice(start, i + 1);
+				try {
+					whole.push(JSON.parse(candidate));
+				} catch {
+					return {
+						whole,
+						fragment: line.slice(start)
+					};
+				}
+				start = i + 1;
+			}
 		}
+	}
+	return {
+		whole,
+		fragment: line.slice(start)
 	};
 }
+var JsonlFileStore = class {
+	dir;
+	/**
+	* The stored tail seq per run, lazily initialized from the file on the
+	* first append this instance performs (obligation A5). Per instance by
+	* design: cross-process writers are the lease seam's job.
+	*/
+	lastSeq = /* @__PURE__ */ new Map();
+	/**
+	* The verify-only load switch (RV1512): with `repairOnLoad: false`,
+	* `load` serves the salvageable records WITHOUT rewriting the file,
+	* so an auditor's "verification" read never destroys the evidence
+	* of a tear it found. The default keeps the owner semantics byte
+	* for byte: a torn tail repairs on load exactly as documented in
+	* the A1 model above. Mutations (`append`, `putMeta`, `delete`)
+	* are unaffected by the flag; an auditor that must not write simply
+	* does not call them.
+	*/
+	repairOnLoad;
+	constructor(options) {
+		this.dir = options.dir;
+		this.repairOnLoad = options.repairOnLoad !== false;
+		mkdirSync(this.dir, { recursive: true });
+	}
+	journalPath(runId) {
+		return join(this.dir, `${safeName(runId)}${JOURNAL_SUFFIX}`);
+	}
+	metaPath(runId) {
+		return join(this.dir, `${safeName(runId)}${META_SUFFIX}`);
+	}
+	async append(runId, e) {
+		let tail = this.lastSeq.get(runId);
+		if (tail === void 0) {
+			const existing = await this.load(runId);
+			this.terminateUnterminatedTail(runId);
+			const last = existing[existing.length - 1];
+			tail = last !== void 0 && Number.isFinite(last.seq) ? last.seq : Number.NEGATIVE_INFINITY;
+			this.lastSeq.set(runId, tail);
+		}
+		if (Number.isFinite(e.seq) && e.seq <= tail) throw new JournalOrderViolation(`JsonlFileStore: append of seq ${e.seq} to run '${runId}' is not after the stored tail seq ${tail}; a concurrent writer raced this journal from a stale tail`);
+		appendFileSync(this.journalPath(runId), `${JSON.stringify(e)}\n`, "utf8");
+		if (Number.isFinite(e.seq)) this.lastSeq.set(runId, e.seq);
+	}
+	async load(runId) {
+		let raw;
+		try {
+			raw = readFileSync(this.journalPath(runId), "utf8");
+		} catch (thrown) {
+			if (thrown.code === "ENOENT") return [];
+			throw thrown;
+		}
+		const lines = raw.split("\n");
+		const entries = [];
+		for (let i = 0; i < lines.length; i += 1) {
+			const line = lines[i] ?? "";
+			if (line === "") continue;
+			try {
+				entries.push(JSON.parse(line));
+			} catch (thrown) {
+				if (lines.slice(i + 1).every((rest) => rest === "")) {
+					for (const value of splitConcatenatedJson(line).whole) entries.push(value);
+					if (this.repairOnLoad) this.repairTornTail(runId, entries);
+					break;
+				}
+				throw new JournalOrderViolation(`JsonlFileStore: corrupt journal line ${i + 1} of run '${runId}' (not the trailing line, so this is not a torn append)`, { cause: thrown });
+			}
+		}
+		return entries;
+	}
+	/**
+	* Restores the trailing '\n' of a parseable-but-unterminated tail
+	* (RV701). One byte appended in place terminates the record exactly
+	* where the crash left it; the file's bytes before it stay untouched.
+	* No-op on a missing, empty, or already-terminated journal.
+	*/
+	terminateUnterminatedTail(runId) {
+		const path = this.journalPath(runId);
+		let fd;
+		try {
+			fd = openSync(path, "r");
+		} catch (thrown) {
+			if (thrown.code === "ENOENT") return;
+			throw thrown;
+		}
+		let needsNewline = false;
+		try {
+			const size = fstatSync(fd).size;
+			if (size > 0) {
+				const lastByte = /* @__PURE__ */ new Uint8Array(1);
+				readSync(fd, lastByte, 0, 1, size - 1);
+				needsNewline = lastByte[0] !== 10;
+			}
+		} finally {
+			closeSync(fd);
+		}
+		if (needsNewline) appendFileSync(path, "\n", "utf8");
+	}
+	repairTornTail(runId, whole) {
+		const path = this.journalPath(runId);
+		const temp = `${path}.tmp`;
+		writeFileSync(temp, whole.map((entry) => JSON.stringify(entry)).join("\n") + (whole.length > 0 ? "\n" : ""), "utf8");
+		renameSync(temp, path);
+	}
+	async putMeta(m) {
+		const path = this.metaPath(m.runId);
+		const temp = `${path}.tmp`;
+		writeFileSync(temp, JSON.stringify(m, null, 2), "utf8");
+		renameSync(temp, path);
+	}
+	async getMeta(runId) {
+		try {
+			return JSON.parse(readFileSync(this.metaPath(runId), "utf8"));
+		} catch {
+			return;
+		}
+	}
+	async listRuns(f) {
+		const metas = [];
+		for (const file of readdirSync(this.dir)) {
+			if (!file.endsWith(META_SUFFIX)) continue;
+			try {
+				metas.push(JSON.parse(readFileSync(join(this.dir, file), "utf8")));
+			} catch {}
+		}
+		return metas.filter((meta) => metaMatchesFilter(meta, f));
+	}
+	async delete(runId) {
+		rmSync(this.journalPath(runId), { force: true });
+		rmSync(this.metaPath(runId), { force: true });
+		this.lastSeq.delete(runId);
+	}
+};
+const TRANSCRIPT_SUFFIX = ".bin";
 /**
-* Dollars from normalized usage against one pricing row: the sum of the
-* {@link priceComponentsOf} terms in their declared order, byte for
-* byte the historical expression (uncached input, output, cached input,
-* cache writes).
-*/
-function priceUsdOf(pricing, usage) {
-	const parts = priceComponentsOf(pricing, usage);
-	return parts.input.usd + parts.output.usd + parts.cachedInput.usd + parts.cacheWrite.usd;
-}
-/**
-* The output tokens `remainingUsd` still buys from one pricing row after
-* paying for an estimated prompt of `estimatedInputTokens`, priced with
-* the same tier rules as settlement (the tier is selected by the
-* estimated prompt). Floored to whole tokens; zero or negative means not
-* even one output token fits, so the turn must not be dispatched.
-* Undefined when the row prices output at zero (a free model needs no
-* output bound).
-*/
-function affordableOutputTokens(pricing, remainingUsd, estimatedInputTokens) {
-	const tier = tierFor(pricing, estimatedInputTokens);
-	const outputRate = pricing.outputUsdPerMTok * (tier?.outputMultiplier ?? 1);
-	if (outputRate <= 0) return;
-	const inputUsd = priceUsdOf(pricing, {
-		inputTokens: estimatedInputTokens,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		cacheWriteTokens: 0
-	});
-	return Math.floor((remainingUsd - inputUsd) / outputRate * 1e6);
-}
-const RATE_FIELDS = [
-	"inputUsdPerMTok",
-	"outputUsdPerMTok",
-	"cacheReadUsdPerMTok",
-	"cacheWriteUsdPerMTok",
-	"cacheWrite1hUsdPerMTok"
-];
-const TIER_FIELDS = [
-	"aboveInputTokens",
-	"inputMultiplier",
-	"outputMultiplier"
-];
-/**
-* Compares a pricing seed against rates extracted from the provider's
-* documented pricing page, in BOTH directions (RV902): a seed rate the
-* page moved or dropped is a finding, and so is a documented billable
-* rate the seed never declared, because a billable column missing from
-* the seed is a silent underpricing channel (the 1h cache-write premium
-* hid exactly there). Declared long-context tiers compare field by
-* field. Returns human-readable findings, empty when the sides agree;
-* the weekly rates audit (scripts/rates-audit.mjs) runs this exact
-* comparator over the live pages, and the fault-injection kit drives it
-* as a permanent gate (RV909). It verifies DOCUMENTATION, not billing:
-* only a statement reconciliation over saved exports settles what the
-* provider's meter actually charges.
+* File-backed TranscriptStore (M6-T02): blobs (transcripts, checkpoints,
+* persisted CompiledWorkflow sources) as one file per ref under `dir`,
+* so compiled runs resume across processes. Refs follow the
+* `<runId>/<name>` convention; nested segments become directories.
+*
+* Every ref is contained under `dir` (v1.36.0 review SEC-P1): each
+* segment must match `[A-Za-z0-9._-]` and be neither empty, '.', nor
+* '..', and the resolved path must stay under the resolved root. A '..'
+* segment used to pass the per-segment alphabet (dots are in it) and, via
+* `join`, escape the root; a caller passing an untrusted ref (or an
+* untrusted runId, which prefixes checkpoint and workflow-source refs)
+* could read, write, or delete `.bin` files outside `dir`.
 */
-function compareRates(seed, page) {
-	const findings = [];
-	for (const field of RATE_FIELDS) {
-		const seedValue = seed[field];
-		const pageValue = page[field];
-		if (seedValue === void 0) {
-			if (pageValue !== void 0) findings.push(`${field}: the page shows ${String(pageValue)} but the seed declares no such rate`);
-			continue;
+var FileTranscriptStore = class {
+	dir;
+	constructor(options) {
+		this.dir = options.dir;
+		mkdirSync(this.dir, { recursive: true });
+	}
+	blobPath(ref) {
+		const segments = ref.split("/");
+		for (const segment of segments) if (segment === "" || segment === "." || segment === ".." || !/^[A-Za-z0-9._-]+$/.test(segment)) throw new JournalOrderViolation(`FileTranscriptStore: ref segment '${segment}' is not filesystem-safe`);
+		const name = segments.pop() ?? "";
+		const path = join(this.dir, ...segments, `${name}${TRANSCRIPT_SUFFIX}`);
+		const root = resolve(this.dir);
+		const resolved = resolve(path);
+		if (resolved !== root && !resolved.startsWith(`${root}${sep}`)) throw new JournalOrderViolation(`FileTranscriptStore: ref '${ref}' resolves outside the configured root`);
+		return path;
+	}
+	async put(ref, blob) {
+		const path = this.blobPath(ref);
+		mkdirSync(dirname(path), { recursive: true });
+		const temp = `${path}.tmp`;
+		writeFileSync(temp, blob);
+		renameSync(temp, path);
+	}
+	async get(ref) {
+		try {
+			return new Uint8Array(readFileSync(this.blobPath(ref)));
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
 		}
-		if (pageValue === void 0) findings.push(`${field}: seed ${String(seedValue)} but the page shows no such rate`);
-		else if (!(Math.abs(seedValue - pageValue) <= 1e-9)) findings.push(`${field}: seed ${String(seedValue)} vs page ${String(pageValue)}`);
 	}
-	const seedTiers = seed.tiers;
-	const pageTiers = page.tiers;
-	if (!Array.isArray(seedTiers)) {
-		if (Array.isArray(pageTiers) && pageTiers.length > 0) findings.push(`tiers: the page shows ${String(pageTiers.length)} but the seed declares none`);
-	} else if (!Array.isArray(pageTiers) || pageTiers.length !== seedTiers.length) findings.push(`tiers: seed declares ${String(seedTiers.length)}, page shows ${Array.isArray(pageTiers) ? String(pageTiers.length) : "none"}`);
-	else for (let i = 0; i < seedTiers.length; i += 1) for (const field of TIER_FIELDS) {
-		const seedValue = seedTiers[i]?.[field] ?? NaN;
-		const pageValue = pageTiers[i]?.[field] ?? NaN;
-		if (!(Math.abs(seedValue - pageValue) <= 1e-9)) findings.push(`tiers[${String(i)}].${field}: seed ${String(seedValue)} vs page ${String(pageValue)}`);
+	async list(runId) {
+		if (runId === "." || runId === "..") throw new JournalOrderViolation(`FileTranscriptStore: runId '${runId}' is not filesystem-safe`);
+		const root = join(this.dir, safeName(runId));
+		const refs = [];
+		const walk = (dir, prefix) => {
+			let names;
+			try {
+				names = readdirSync(dir);
+			} catch {
+				return;
+			}
+			for (const name of names) {
+				const path = join(dir, name);
+				if (statSync(path).isDirectory()) walk(path, `${prefix}${name}/`);
+				else if (name.endsWith(TRANSCRIPT_SUFFIX)) refs.push(`${prefix}${name.slice(0, -4)}`);
+			}
+		};
+		walk(root, `${runId}/`);
+		return refs.sort();
 	}
-	return findings;
-}
+	async delete(ref) {
+		try {
+			rmSync(this.blobPath(ref));
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+};
 //#endregion
-//#region src/model/quota.ts
+//#region src/model/pricing.ts
 /**
-* Quota rules and the in-process reference QuotaLimiter (RV-215).
-* The rule model is shared by every reference implementation
-* (memoryQuotaLimiter here, SqliteQuotaLimiter in
-* @rulvar/store-sqlite): fixed one-minute windows aligned to the
-* epoch, admission at reservation time, reconciliation to actual
-* usage inside the same window. The hard guarantee is on
+* Resolves the pricing for a model: the versioned table wins; the
+* adapter-reported caps.pricing is the fallback; undefined means
+* unpriced (the CostReport surfaces it, never a silent zero).
+*/
+function resolvePricing(ref, table, capsPricing) {
+	return table?.models[ref] ?? capsPricing;
+}
+/** The tier a full prompt lands in: the highest threshold strictly below it. */
+function tierFor(pricing, inputTokens) {
+	let tier;
+	for (const candidate of pricing.tiers ?? []) if (inputTokens > candidate.aboveInputTokens && (tier === void 0 || candidate.aboveInputTokens > tier.aboveInputTokens)) tier = candidate;
+	return tier;
+}
+/**
+* Decomposes one usage against one pricing row into the four billing
+* components. Under the Usage invariant inputTokens is the FULL prompt
+* including cache reads and writes, so the input rate bills only the
+* uncached remainder and cache tokens bill at their own rates, never
+* twice; a row that omits a cache rate bills those tokens at the plain
+* input rate rather than silently for free. A row may carry
+* long-context tiers: the highest threshold strictly below the full
+* prompt re-prices the ENTIRE request (input-side rates scale by
+* inputMultiplier, the output rate by outputMultiplier). Cache writes
+* price at the 5m premium rate by default; when the usage carries the
+* TTL split (RV810: `cacheWrite5mTokens` and `cacheWrite1hTokens`,
+* filled by adapters whose provider distinguishes write TTLs), the 1h
+* share prices at `cacheWrite1hUsdPerMTok` (falling back to the plain
+* write rate when the row lacks it) and everything the 1h share does
+* not claim, the 5m share plus any unattributed remainder an upstream
+* invariant violation left, bills at the write rate, never silently
+* for free. The component's `tokens` stays the WHOLE
+* `cacheWriteTokens` either way, so statement reconciliation keys are
+* unchanged.
+*/
+function priceComponentsOf(pricing, usage) {
+	const tier = tierFor(pricing, usage.inputTokens);
+	const inputMul = tier?.inputMultiplier ?? 1;
+	const outputMul = tier?.outputMultiplier ?? 1;
+	const uncachedInputTokens = Math.max(0, usage.inputTokens - usage.cacheReadTokens - usage.cacheWriteTokens);
+	const writeRate = pricing.cacheWriteUsdPerMTok ?? pricing.inputUsdPerMTok;
+	const write1hRate = pricing.cacheWrite1hUsdPerMTok ?? writeRate;
+	const write1hTokens = usage.cacheWrite5mTokens !== void 0 || usage.cacheWrite1hTokens !== void 0 ? usage.cacheWrite1hTokens ?? 0 : 0;
+	const writeDefaultTokens = Math.max(0, usage.cacheWriteTokens - write1hTokens);
+	return {
+		input: {
+			tokens: uncachedInputTokens,
+			usd: uncachedInputTokens / 1e6 * pricing.inputUsdPerMTok * inputMul
+		},
+		output: {
+			tokens: usage.outputTokens,
+			usd: usage.outputTokens / 1e6 * pricing.outputUsdPerMTok * outputMul
+		},
+		cachedInput: {
+			tokens: usage.cacheReadTokens,
+			usd: usage.cacheReadTokens / 1e6 * (pricing.cacheReadUsdPerMTok ?? pricing.inputUsdPerMTok) * inputMul
+		},
+		cacheWrite: {
+			tokens: usage.cacheWriteTokens,
+			usd: (writeDefaultTokens / 1e6 * writeRate + write1hTokens / 1e6 * write1hRate) * inputMul
+		}
+	};
+}
+/**
+* Dollars from normalized usage against one pricing row: the sum of the
+* {@link priceComponentsOf} terms in their declared order, byte for
+* byte the historical expression (uncached input, output, cached input,
+* cache writes).
+*/
+function priceUsdOf(pricing, usage) {
+	const parts = priceComponentsOf(pricing, usage);
+	return parts.input.usd + parts.output.usd + parts.cachedInput.usd + parts.cacheWrite.usd;
+}
+/**
+* The output tokens `remainingUsd` still buys from one pricing row after
+* paying for an estimated prompt of `estimatedInputTokens`, priced with
+* the same tier rules as settlement (the tier is selected by the
+* estimated prompt). Floored to whole tokens; zero or negative means not
+* even one output token fits, so the turn must not be dispatched.
+* Undefined when the row prices output at zero (a free model needs no
+* output bound).
+*/
+function affordableOutputTokens(pricing, remainingUsd, estimatedInputTokens) {
+	const tier = tierFor(pricing, estimatedInputTokens);
+	const outputRate = pricing.outputUsdPerMTok * (tier?.outputMultiplier ?? 1);
+	if (outputRate <= 0) return;
+	const inputUsd = priceUsdOf(pricing, {
+		inputTokens: estimatedInputTokens,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0
+	});
+	return Math.floor((remainingUsd - inputUsd) / outputRate * 1e6);
+}
+const RATE_FIELDS = [
+	"inputUsdPerMTok",
+	"outputUsdPerMTok",
+	"cacheReadUsdPerMTok",
+	"cacheWriteUsdPerMTok",
+	"cacheWrite1hUsdPerMTok"
+];
+const TIER_FIELDS = [
+	"aboveInputTokens",
+	"inputMultiplier",
+	"outputMultiplier"
+];
+/**
+* Compares a pricing seed against rates extracted from the provider's
+* documented pricing page, in BOTH directions (RV902): a seed rate the
+* page moved or dropped is a finding, and so is a documented billable
+* rate the seed never declared, because a billable column missing from
+* the seed is a silent underpricing channel (the 1h cache-write premium
+* hid exactly there). Declared long-context tiers compare field by
+* field. Returns human-readable findings, empty when the sides agree;
+* the weekly rates audit (scripts/rates-audit.mjs) runs this exact
+* comparator over the live pages, and the fault-injection kit drives it
+* as a permanent gate (RV909). It verifies DOCUMENTATION, not billing:
+* only a statement reconciliation over saved exports settles what the
+* provider's meter actually charges.
+*/
+function compareRates(seed, page) {
+	const findings = [];
+	for (const field of RATE_FIELDS) {
+		const seedValue = seed[field];
+		const pageValue = page[field];
+		if (seedValue === void 0) {
+			if (pageValue !== void 0) findings.push(`${field}: the page shows ${String(pageValue)} but the seed declares no such rate`);
+			continue;
+		}
+		if (pageValue === void 0) findings.push(`${field}: seed ${String(seedValue)} but the page shows no such rate`);
+		else if (!(Math.abs(seedValue - pageValue) <= 1e-9)) findings.push(`${field}: seed ${String(seedValue)} vs page ${String(pageValue)}`);
+	}
+	const seedTiers = seed.tiers;
+	const pageTiers = page.tiers;
+	if (!Array.isArray(seedTiers)) {
+		if (Array.isArray(pageTiers) && pageTiers.length > 0) findings.push(`tiers: the page shows ${String(pageTiers.length)} but the seed declares none`);
+	} else if (!Array.isArray(pageTiers) || pageTiers.length !== seedTiers.length) findings.push(`tiers: seed declares ${String(seedTiers.length)}, page shows ${Array.isArray(pageTiers) ? String(pageTiers.length) : "none"}`);
+	else for (let i = 0; i < seedTiers.length; i += 1) for (const field of TIER_FIELDS) {
+		const seedValue = seedTiers[i]?.[field] ?? NaN;
+		const pageValue = pageTiers[i]?.[field] ?? NaN;
+		if (!(Math.abs(seedValue - pageValue) <= 1e-9)) findings.push(`tiers[${String(i)}].${field}: seed ${String(seedValue)} vs page ${String(pageValue)}`);
+	}
+	return findings;
+}
+//#endregion
+//#region src/model/quota.ts
+/**
+* Quota rules and the in-process reference QuotaLimiter (RV-215).
+* The rule model is shared by every reference implementation
+* (memoryQuotaLimiter here, SqliteQuotaLimiter in
+* @rulvar/store-sqlite): fixed one-minute windows aligned to the
+* epoch, admission at reservation time, reconciliation to actual
+* usage inside the same window. The hard guarantee is on
 * `requestsPerMinute` (every wire attempt is exactly one request);
 * `tokensPerMinute` admits on the heuristic estimate and settles to
 * actual usage, so token windows are approximate at admission and
@@ -15743,6 +16329,94 @@ function statementFromRows(input) {
 		})
 	};
 }
+/**
+* Parses a delimited billing export (the CSV/TSV a provider console
+* hands a host) into the header-keyed rows {@link statementFromRows}
+* consumes (RV2908). The library deliberately hard-codes NO provider's
+* export format: the host owns the column map, this owns only the
+* delimited grammar, and the pair closes the last manual step between
+* a downloaded export and {@link reconcileStatement}.
+*
+* Fail-closed at the record, like the rest of this module: a data row
+* whose cell count differs from the header, a quote opened and never
+* closed, a stray quote inside an unquoted cell, an empty or duplicate
+* header name, all refuse typed with the line instead of flowing a
+* shifted column into a reconciliation, because a column shifted one
+* to the left prices `outputTokens` as dollars and calls it evidence.
+* RFC 4180 quoting is honored (quoted cells may carry the delimiter,
+* doubled quotes, and line breaks); CRLF and lone LF both delimit
+* records; one trailing empty line is an artifact of every exporter
+* and is ignored. Cells come back as raw strings, so an empty cell
+* reads as "the export does not carry this figure" downstream, exactly
+* the absence contract `statementFromRows` documents.
+*/
+function statementRowsFromDelimited(text, options) {
+	const delimiter = options?.delimiter ?? ",";
+	const records = [];
+	let cells = [];
+	let cell = "";
+	let quoted = false;
+	let cellHadQuote = false;
+	let line = 1;
+	const endCell = () => {
+		cells.push(cell);
+		cell = "";
+		cellHadQuote = false;
+	};
+	const endRecord = () => {
+		endCell();
+		records.push(cells);
+		cells = [];
+	};
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (quoted) {
+			if (char === "\"") {
+				if (text[index + 1] === "\"") {
+					cell += "\"";
+					index += 1;
+					continue;
+				}
+				quoted = false;
+				continue;
+			}
+			if (char === "\n") line += 1;
+			cell += char;
+			continue;
+		}
+		if (char === "\"") {
+			if (cell.length > 0 || cellHadQuote) throw new ConfigError(`statementRowsFromDelimited: line ${String(line)} carries a quote inside an unquoted cell; quote the whole cell (RFC 4180) or fix the export`);
+			quoted = true;
+			cellHadQuote = true;
+			continue;
+		}
+		if (char === delimiter) {
+			endCell();
+			continue;
+		}
+		if (char === "\r" && text[index + 1] === "\n") continue;
+		if (char === "\n") {
+			endRecord();
+			line += 1;
+			continue;
+		}
+		cell += char;
+	}
+	if (quoted) throw new ConfigError(`statementRowsFromDelimited: a quoted cell opened on line ${String(line)} never closes; the export is torn`);
+	if (cell.length > 0 || cellHadQuote || cells.length > 0) endRecord();
+	if (records.length === 0) throw new ConfigError("statementRowsFromDelimited: the export carries no header record");
+	const header = records[0];
+	const seen = /* @__PURE__ */ new Set();
+	header.forEach((name, index) => {
+		if (name.length === 0) throw new ConfigError(`statementRowsFromDelimited: header column ${String(index)} is empty; every column needs a name for the map to address`);
+		if (seen.has(name)) throw new ConfigError(`statementRowsFromDelimited: header names column '${name}' twice; an ambiguous address cannot be mapped`);
+		seen.add(name);
+	});
+	return records.slice(1).map((record, index) => {
+		if (record.length !== header.length) throw new ConfigError(`statementRowsFromDelimited: data record ${String(index)} carries ${String(record.length)} cell(s) against ${String(header.length)} header column(s); a shifted column prices the wrong figure, so a ragged export refuses instead`);
+		return Object.fromEntries(header.map((name, column) => [name, record[column]]));
+	});
+}
 //#endregion
 //#region src/engine/persisted-terminal.ts
 const REFUSAL_MESSAGES = {
@@ -16488,484 +17162,196 @@ var AdmissionController = class {
 			depth,
 			...evaluated.statsBefore === void 0 ? {} : { lineage: evaluated.statsBefore }
 		};
-		if (evaluated.decision.kind === "reject") return {
-			verdict: {
-				kind: "reject",
-				reason: evaluated.decision.reason
-			},
-			statsBefore
-		};
-		if (this.terminationAccount !== void 0) {
-			if ((spec.ladderLength ?? 1) > this.terminationAccount.limits.kMax) return {
-				verdict: {
-					kind: "reject",
-					reason: { code: "ladder_exceeds_frozen" }
-				},
-				statsBefore
-			};
-			if (this.terminationAccount.spawnUnitsExhausted) return {
-				verdict: {
-					kind: "reject",
-					reason: { code: "termination_exhausted" }
-				},
-				statsBefore
-			};
-		}
-		if (depth > this.maxDepth) return {
-			verdict: {
-				kind: "reject",
-				reason: { code: "depth" }
-			},
-			statsBefore
-		};
-		if (childrenBefore >= this.maxChildrenPerNode) return {
-			verdict: {
-				kind: "reject",
-				reason: { code: "quota" }
-			},
-			statsBefore
-		};
-		if (this.maxTotalSpawns !== void 0 && this.admittedTotal >= this.maxTotalSpawns) return {
-			verdict: {
-				kind: "reject",
-				reason: { code: "lifetime" }
-			},
-			statsBefore
-		};
-		if (spec.roster !== void 0) {
-			const seatsRemaining = spec.roster.floor - spec.roster.admittedChildren;
-			if (seatsRemaining > 0) {
-				const perSeatProjectionUsd = this.projectedDispatchReserveUsd(spec);
-				const remainder = this.budget.remainderOf(spec.parentAccountScope);
-				if (remainder !== void 0 && remainder < seatsRemaining * perSeatProjectionUsd + spec.roster.liveExposureUsd) return {
-					verdict: {
-						kind: "reject",
-						reason: {
-							code: "roster_floor",
-							floor: spec.roster.floor,
-							admittedChildren: spec.roster.admittedChildren,
-							seatsRemaining,
-							perSeatProjectionUsd,
-							liveExposureUsd: spec.roster.liveExposureUsd,
-							remainderUsd: remainder
-						}
-					},
-					statsBefore
-				};
-			}
-		}
-		const spawnToolOrigin = spec.origin === "spawn_agent" || spec.origin === "parallel_agents";
-		let childCeilingUsd;
-		const parentRemainder = this.budget.remainderOf(spec.parentAccountScope);
-		if (spawnToolOrigin) {
-			if (spec.budgetUsd !== void 0) childCeilingUsd = spec.budgetUsd;
-		} else if (parentRemainder !== void 0) {
-			const fractionCap = this.childBudgetFraction * parentRemainder;
-			childCeilingUsd = spec.budgetUsd === void 0 ? fractionCap : Math.min(spec.budgetUsd, fractionCap);
-		} else if (spec.budgetUsd !== void 0) childCeilingUsd = spec.budgetUsd;
-		let reserveUsd = spec.estCostUsd ?? this.flatReserveUsd;
-		const source = spec.estCostUsd === void 0 ? "default" : "estCost";
-		let clampedBy;
-		if (childCeilingUsd !== void 0 && reserveUsd > childCeilingUsd) {
-			clampedBy = spec.budgetUsd !== void 0 && childCeilingUsd === spec.budgetUsd ? "explicit-budget" : "fraction-ceiling";
-			reserveUsd = childCeilingUsd;
-		}
-		const reserve = {
-			reserveUsd,
-			source
-		};
-		if (clampedBy !== void 0) reserve.clampedBy = clampedBy;
-		if (childCeilingUsd !== void 0) reserve.childCeilingUsd = childCeilingUsd;
-		if (this.budget.spawnHeadroom <= 0) return {
-			verdict: {
-				kind: "reject",
-				reason: { code: "lifetime" }
-			},
-			statsBefore
-		};
-		if (commitReserve) try {
-			this.budget.admitSpawn(reserveUsd, spec.parentAccountScope);
-		} catch {
-			return {
-				verdict: {
-					kind: "reject",
-					reason: { code: "budget" }
-				},
-				statsBefore
-			};
-		}
-		else {
-			const remainder = this.budget.remainderOf(spec.parentAccountScope);
-			const projection = this.projectedDispatchReserveUsd(spec);
-			if (remainder !== void 0 && (remainder <= 0 || remainder < projection + (spec.pendingReserveUsd ?? 0))) return {
-				verdict: {
-					kind: "reject",
-					reason: { code: "budget" }
-				},
-				statsBefore
-			};
-		}
-		this.childrenOf.set(nodeKey, childrenBefore + 1);
-		this.admittedTotal += 1;
-		const lineage = evaluated.decision.lineage;
-		this.registerLineageAdmit(lineage.logicalTaskId);
-		let spawnUnitsAfter = this.budget.spawnHeadroom;
-		if (this.terminationAccount !== void 0) {
-			const debited = this.terminationAccount.debitSpawn({
-				logicalTaskId: lineage.logicalTaskId,
-				isNew: spec.lineage === void 0,
-				ladderLength: spec.ladderLength ?? 1
-			});
-			if (!debited.ok) return {
-				verdict: {
-					kind: "reject",
-					reason: { code: "termination_exhausted" }
-				},
-				statsBefore
-			};
-			spawnUnitsAfter = debited.spawnUnitsAfter;
-		}
-		return {
-			verdict: {
-				kind: "admit",
-				reserve,
-				spawnUnitsAfter,
-				lineage: {
-					logicalTaskId: lineage.logicalTaskId,
-					isNew: spec.lineage === void 0,
-					depth
-				}
-			},
-			statsBefore,
-			nodeId: this.mintId(),
-			lineage,
-			...this.terminationAccount === void 0 ? {} : { ladderLength: spec.ladderLength ?? 1 }
-		};
-	}
-	/**
-	* Resume roll-forward for an orchestrator child (M6-T07): restores the
-	* children-quota counter only. The budget seed already counts settled
-	* agent dispatches, and an in-flight child re-commits its reserve
-	* through the ctx.agent dispatch path.
-	*/
-	recoverChild(nodeKey) {
-		this.childrenOf.set(nodeKey, (this.childrenOf.get(nodeKey) ?? 0) + 1);
-		this.admittedTotal += 1;
-	}
-	/**
-	* Resume roll-forward for a child that already SETTLED before the
-	* resume: re-registers the counters (maxChildrenPerNode, the lifetime
-	* cap, statsBefore fidelity) without committing any reserve; the spend
-	* itself sits in the root ledger seed.
-	*/
-	recoverSettled(parentAccountScope) {
-		this.budget.admitRecovered(0, parentAccountScope);
-		this.childrenOf.set(parentAccountScope, (this.childrenOf.get(parentAccountScope) ?? 0) + 1);
-		this.admittedTotal += 1;
-	}
-	/**
-	* Resume roll-forward for an admission whose decision entry exists but
-	* whose child has NOT settled: re-applies the recorded reserve and
-	* counters without re-evaluating any limit (replay never
-	* re-evaluates admission; reserves are recovered, never
-	* re-estimated).
-	*/
-	recoverInFlight(parentAccountScope, verdict) {
-		if (verdict.kind === "reject") return;
-		const reserveUsd = verdict.kind === "reuse_full" ? 0 : verdict.reserve.reserveUsd;
-		this.budget.admitRecovered(reserveUsd, parentAccountScope);
-		this.childrenOf.set(parentAccountScope, (this.childrenOf.get(parentAccountScope) ?? 0) + 1);
-		this.admittedTotal += 1;
-	}
-};
-//#endregion
-//#region src/l0/telemetry-reduce.ts
-const ZERO = {
-	inputTokens: 0,
-	outputTokens: 0,
-	cacheReadTokens: 0,
-	cacheWriteTokens: 0
-};
-/**
-* Reduces one run's event stream (or any slice of it) to the invocation
-* table. Feed it the events in emission order; both a live stream and a
-* replayed one produce the same usage and cost columns.
-*/
-function reduceInvocationTable(events) {
-	const rows = /* @__PURE__ */ new Map();
-	const order = [];
-	const openPhases = /* @__PURE__ */ new Map();
-	const byRole = {};
-	let totalCostUsd = 0;
-	const rowFor = (event) => {
-		let row = rows.get(event.spanId);
-		if (row === void 0) {
-			row = {
-				spanId: event.spanId,
-				agentType: event.agentType,
-				...event.label === void 0 ? {} : { label: event.label },
-				usage: ZERO,
-				costUsd: 0,
-				costBasis: "aggregate-estimate",
-				usageApprox: false,
-				retryCount: 0,
-				replayed: event.replayed === true,
-				open: true,
-				phases: []
-			};
-			rows.set(event.spanId, row);
-			order.push(row);
-		}
-		return row;
-	};
-	for (const event of events) switch (event.type) {
-		case "agent:start": {
-			const row = rowFor(event);
-			row.role = event.role;
-			break;
-		}
-		case "agent:phase:start": {
-			const row = rowFor(event);
-			const phase = {
-				invocation: event.invocation,
-				role: event.role,
-				model: event.model,
-				durationMs: 0,
-				usage: ZERO,
-				costUsd: 0,
-				costBasis: "aggregate-estimate",
-				retries: 0,
-				replayed: event.replayed === true,
-				open: true
-			};
-			row.phases.push(phase);
-			openPhases.set(`${event.spanId}#${event.invocation}`, phase);
-			break;
-		}
-		case "agent:phase:end": {
-			const key = `${event.spanId}#${event.invocation}`;
-			let phase = openPhases.get(key);
-			if (phase === void 0) {
-				phase = {
-					invocation: event.invocation,
-					role: event.role,
-					model: event.model,
-					durationMs: 0,
-					usage: ZERO,
-					costUsd: 0,
-					costBasis: "aggregate-estimate",
-					retries: 0,
-					replayed: event.replayed === true,
-					open: true
-				};
-				rowFor(event).phases.push(phase);
-			}
-			openPhases.delete(key);
-			phase.open = false;
-			phase.role = event.role;
-			phase.model = event.model;
-			phase.durationMs = event.durationMs;
-			phase.usage = event.usage;
-			phase.costUsd = event.costUsd;
-			phase.costBasis = event.costBasis ?? "aggregate-estimate";
-			phase.outcome = event.outcome;
-			phase.retries = event.retries ?? 0;
-			const bucket = byRole[event.role] ??= {
-				usage: ZERO,
-				costUsd: 0,
-				costBasis: "per-call"
-			};
-			bucket.usage = sumUsage(bucket.usage, event.usage);
-			bucket.costUsd += event.costUsd;
-			if (phase.costBasis === "aggregate-estimate") bucket.costBasis = "aggregate-estimate";
-			break;
-		}
-		case "agent:end": {
-			const row = rowFor(event);
-			row.open = false;
-			row.status = event.status;
-			row.usage = event.usage;
-			row.costUsd = event.costUsd;
-			row.costBasis = event.costBasis ?? "aggregate-estimate";
-			row.usageApprox = event.usageApprox === true;
-			row.retryCount = event.retryCount ?? 0;
-			if (event.toolBudget !== void 0) row.toolBudget = event.toolBudget;
-			totalCostUsd += event.costUsd;
-			break;
-		}
-		default: break;
-	}
-	return {
-		agents: order,
-		byRole,
-		totalCostUsd
-	};
-}
-/**
-* The label the claim-consistency judge invocation dispatches under
-* (RV1502; named here since RV1604 so the critical-path reducer and the
-* orchestrator share one constant): the judge rides role 'synthesize',
-* and this label is what tells its wall apart from a real final
-* composition in {@link reduceCriticalPath}.
-*/
-const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
-/** Total length of the union of possibly overlapping intervals. */
-function unionLength(intervals) {
-	const positive = intervals.filter((interval) => interval.to > interval.from);
-	if (positive.length === 0) return 0;
-	const sorted = [...positive].sort((a, b) => a.from - b.from);
-	let total = 0;
-	let from = sorted[0]?.from ?? 0;
-	let to = sorted[0]?.to ?? 0;
-	for (const interval of sorted.slice(1)) if (interval.from > to) {
-		total += to - from;
-		from = interval.from;
-		to = interval.to;
-	} else if (interval.to > to) to = interval.to;
-	return total + (to - from);
-}
-function reduceCriticalPath(events) {
-	let runStart;
-	let runEnd;
-	const startBySpan = /* @__PURE__ */ new Map();
-	let lastWorkerEnd;
-	let workerSpans = 0;
-	let synthesisMs = 0;
-	let finalCompositionMs = 0;
-	let semanticJudgeMs = 0;
-	const coordinationModel = [];
-	const coordinationTools = [];
-	const synthesisSpans = [];
-	const spanOf = (durationMs) => Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
-	for (const event of events) {
-		const at = Date.parse(event.ts);
-		if (!Number.isFinite(at)) continue;
-		switch (event.type) {
-			case "run:start":
-				runStart ??= at;
-				break;
-			case "run:end":
-				runEnd = at;
-				break;
-			case "agent:start":
-				startBySpan.set(event.spanId, {
-					role: event.role,
-					at,
-					...event.label === void 0 ? {} : { label: event.label }
-				});
-				break;
-			case "agent:phase:end":
-				if (startBySpan.get(event.spanId)?.role === "orchestrate") coordinationModel.push({
-					phase: event.role,
-					from: at - spanOf(event.durationMs),
-					to: at
-				});
-				break;
-			case "tool:end":
-				if (startBySpan.get(event.spanId)?.role === "orchestrate") coordinationTools.push({
-					name: event.toolName,
-					from: at - spanOf(event.durationMs),
-					to: at
-				});
-				break;
-			case "agent:end": {
-				const started = startBySpan.get(event.spanId);
-				if (started === void 0) break;
-				if (started.role === "synthesize") {
-					const wall = Math.max(0, at - started.at);
-					const judge = started.label === CLAIM_JUDGE_LABEL;
-					synthesisMs += wall;
-					if (judge) semanticJudgeMs += wall;
-					else finalCompositionMs += wall;
-					synthesisSpans.push({
-						from: started.at,
-						to: at,
-						judge
-					});
-				} else if (started.role !== "orchestrate") {
-					workerSpans += 1;
-					lastWorkerEnd = lastWorkerEnd === void 0 ? at : Math.max(lastWorkerEnd, at);
-				}
-				break;
+		if (evaluated.decision.kind === "reject") return {
+			verdict: {
+				kind: "reject",
+				reason: evaluated.decision.reason
+			},
+			statsBefore
+		};
+		if (this.terminationAccount !== void 0) {
+			if ((spec.ladderLength ?? 1) > this.terminationAccount.limits.kMax) return {
+				verdict: {
+					kind: "reject",
+					reason: { code: "ladder_exceeds_frozen" }
+				},
+				statsBefore
+			};
+			if (this.terminationAccount.spawnUnitsExhausted) return {
+				verdict: {
+					kind: "reject",
+					reason: { code: "termination_exhausted" }
+				},
+				statsBefore
+			};
+		}
+		if (depth > this.maxDepth) return {
+			verdict: {
+				kind: "reject",
+				reason: { code: "depth" }
+			},
+			statsBefore
+		};
+		if (childrenBefore >= this.maxChildrenPerNode) return {
+			verdict: {
+				kind: "reject",
+				reason: { code: "quota" }
+			},
+			statsBefore
+		};
+		if (this.maxTotalSpawns !== void 0 && this.admittedTotal >= this.maxTotalSpawns) return {
+			verdict: {
+				kind: "reject",
+				reason: { code: "lifetime" }
+			},
+			statsBefore
+		};
+		if (spec.roster !== void 0) {
+			const seatsRemaining = spec.roster.floor - spec.roster.admittedChildren;
+			if (seatsRemaining > 0) {
+				const perSeatProjectionUsd = this.projectedDispatchReserveUsd(spec);
+				const remainder = this.budget.remainderOf(spec.parentAccountScope);
+				if (remainder !== void 0 && remainder < seatsRemaining * perSeatProjectionUsd + spec.roster.liveExposureUsd) return {
+					verdict: {
+						kind: "reject",
+						reason: {
+							code: "roster_floor",
+							floor: spec.roster.floor,
+							admittedChildren: spec.roster.admittedChildren,
+							seatsRemaining,
+							perSeatProjectionUsd,
+							liveExposureUsd: spec.roster.liveExposureUsd,
+							remainderUsd: remainder
+						}
+					},
+					statsBefore
+				};
 			}
-			default: break;
 		}
-	}
-	const path = {
-		synthesisMs,
-		finalCompositionMs,
-		semanticJudgeMs,
-		workerSpans
-	};
-	if (runStart !== void 0 && runEnd !== void 0) path.runWallMs = Math.max(0, runEnd - runStart);
-	if (runEnd !== void 0 && lastWorkerEnd !== void 0) {
-		path.postFanInMs = Math.max(0, runEnd - lastWorkerEnd);
-		const windowFrom = Math.min(lastWorkerEnd, runEnd);
-		const windowTo = runEnd;
-		const clip = (interval) => {
-			if (interval.to < windowFrom || interval.from > windowTo) return;
+		const spawnToolOrigin = spec.origin === "spawn_agent" || spec.origin === "parallel_agents";
+		let childCeilingUsd;
+		const parentRemainder = this.budget.remainderOf(spec.parentAccountScope);
+		if (spawnToolOrigin) {
+			if (spec.budgetUsd !== void 0) childCeilingUsd = spec.budgetUsd;
+		} else if (parentRemainder !== void 0) {
+			const fractionCap = this.childBudgetFraction * parentRemainder;
+			childCeilingUsd = spec.budgetUsd === void 0 ? fractionCap : Math.min(spec.budgetUsd, fractionCap);
+		} else if (spec.budgetUsd !== void 0) childCeilingUsd = spec.budgetUsd;
+		let reserveUsd = spec.estCostUsd ?? this.flatReserveUsd;
+		const source = spec.estCostUsd === void 0 ? "default" : "estCost";
+		let clampedBy;
+		if (childCeilingUsd !== void 0 && reserveUsd > childCeilingUsd) {
+			clampedBy = spec.budgetUsd !== void 0 && childCeilingUsd === spec.budgetUsd ? "explicit-budget" : "fraction-ceiling";
+			reserveUsd = childCeilingUsd;
+		}
+		const reserve = {
+			reserveUsd,
+			source
+		};
+		if (clampedBy !== void 0) reserve.clampedBy = clampedBy;
+		if (childCeilingUsd !== void 0) reserve.childCeilingUsd = childCeilingUsd;
+		if (this.budget.spawnHeadroom <= 0) return {
+			verdict: {
+				kind: "reject",
+				reason: { code: "lifetime" }
+			},
+			statsBefore
+		};
+		if (commitReserve) try {
+			this.budget.admitSpawn(reserveUsd, spec.parentAccountScope);
+		} catch {
 			return {
-				from: Math.max(interval.from, windowFrom),
-				to: Math.min(interval.to, windowTo)
+				verdict: {
+					kind: "reject",
+					reason: { code: "budget" }
+				},
+				statsBefore
 			};
-		};
-		const byPhase = {};
-		const modelClipped = [];
-		for (const interval of coordinationModel) {
-			const clipped = clip(interval);
-			if (clipped === void 0) continue;
-			byPhase[interval.phase] = (byPhase[interval.phase] ?? 0) + (clipped.to - clipped.from);
-			modelClipped.push(clipped);
 		}
-		const synthesisClipped = [];
-		let judgeClippedMs = 0;
-		let compositionClippedMs = 0;
-		for (const span of synthesisSpans) {
-			const clipped = clip(span);
-			if (clipped === void 0) continue;
-			synthesisClipped.push(clipped);
-			if (span.judge) judgeClippedMs += clipped.to - clipped.from;
-			else compositionClippedMs += clipped.to - clipped.from;
+		else {
+			const remainder = this.budget.remainderOf(spec.parentAccountScope);
+			const projection = this.projectedDispatchReserveUsd(spec);
+			if (remainder !== void 0 && (remainder <= 0 || remainder < projection + (spec.pendingReserveUsd ?? 0))) return {
+				verdict: {
+					kind: "reject",
+					reason: { code: "budget" }
+				},
+				statsBefore
+			};
 		}
-		const byName = {};
-		const callsByName = {};
-		const toolsClipped = [];
-		for (const interval of coordinationTools) {
-			const clipped = clip(interval);
-			if (clipped === void 0) continue;
-			byName[interval.name] = (byName[interval.name] ?? 0) + (clipped.to - clipped.from);
-			callsByName[interval.name] = (callsByName[interval.name] ?? 0) + 1;
-			toolsClipped.push(clipped);
+		this.childrenOf.set(nodeKey, childrenBefore + 1);
+		this.admittedTotal += 1;
+		const lineage = evaluated.decision.lineage;
+		this.registerLineageAdmit(lineage.logicalTaskId);
+		let spawnUnitsAfter = this.budget.spawnHeadroom;
+		if (this.terminationAccount !== void 0) {
+			const debited = this.terminationAccount.debitSpawn({
+				logicalTaskId: lineage.logicalTaskId,
+				isNew: spec.lineage === void 0,
+				ladderLength: spec.ladderLength ?? 1
+			});
+			if (!debited.ok) return {
+				verdict: {
+					kind: "reject",
+					reason: { code: "termination_exhausted" }
+				},
+				statsBefore
+			};
+			spawnUnitsAfter = debited.spawnUnitsAfter;
 		}
-		const lengthOf = (intervals) => intervals.reduce((sum, interval) => sum + (interval.to - interval.from), 0);
-		const coveredMs = unionLength([
-			...modelClipped,
-			...toolsClipped,
-			...synthesisClipped
-		]);
-		const modelOnlyMs = unionLength([...modelClipped, ...toolsClipped]) - unionLength(toolsClipped);
-		const breakdown = {
-			coordinationModelMs: lengthOf(modelClipped),
-			coordinationModelMsByPhase: byPhase,
-			coordinationModelOnlyMs: modelOnlyMs,
-			coordinationToolMs: lengthOf(toolsClipped),
-			coordinationToolMsByName: byName,
-			coordinationToolCallsByName: callsByName,
-			synthesisMs: lengthOf(synthesisClipped),
-			finalCompositionMs: compositionClippedMs,
-			semanticJudgeMs: judgeClippedMs,
-			coveredMs,
-			residueMs: Math.max(0, path.postFanInMs - coveredMs)
+		return {
+			verdict: {
+				kind: "admit",
+				reserve,
+				spawnUnitsAfter,
+				lineage: {
+					logicalTaskId: lineage.logicalTaskId,
+					isNew: spec.lineage === void 0,
+					depth
+				}
+			},
+			statsBefore,
+			nodeId: this.mintId(),
+			lineage,
+			...this.terminationAccount === void 0 ? {} : { ladderLength: spec.ladderLength ?? 1 }
 		};
-		if (path.postFanInMs > 0) breakdown.residueShare = breakdown.residueMs / path.postFanInMs;
-		path.postFanIn = breakdown;
 	}
-	if (path.runWallMs !== void 0 && path.runWallMs > 0) {
-		if (path.postFanInMs !== void 0) path.postFanInShare = path.postFanInMs / path.runWallMs;
-		path.synthesisShare = synthesisMs / path.runWallMs;
+	/**
+	* Resume roll-forward for an orchestrator child (M6-T07): restores the
+	* children-quota counter only. The budget seed already counts settled
+	* agent dispatches, and an in-flight child re-commits its reserve
+	* through the ctx.agent dispatch path.
+	*/
+	recoverChild(nodeKey) {
+		this.childrenOf.set(nodeKey, (this.childrenOf.get(nodeKey) ?? 0) + 1);
+		this.admittedTotal += 1;
 	}
-	return path;
-}
+	/**
+	* Resume roll-forward for a child that already SETTLED before the
+	* resume: re-registers the counters (maxChildrenPerNode, the lifetime
+	* cap, statsBefore fidelity) without committing any reserve; the spend
+	* itself sits in the root ledger seed.
+	*/
+	recoverSettled(parentAccountScope) {
+		this.budget.admitRecovered(0, parentAccountScope);
+		this.childrenOf.set(parentAccountScope, (this.childrenOf.get(parentAccountScope) ?? 0) + 1);
+		this.admittedTotal += 1;
+	}
+	/**
+	* Resume roll-forward for an admission whose decision entry exists but
+	* whose child has NOT settled: re-applies the recorded reserve and
+	* counters without re-evaluating any limit (replay never
+	* re-evaluates admission; reserves are recovered, never
+	* re-estimated).
+	*/
+	recoverInFlight(parentAccountScope, verdict) {
+		if (verdict.kind === "reject") return;
+		const reserveUsd = verdict.kind === "reuse_full" ? 0 : verdict.reserve.reserveUsd;
+		this.budget.admitRecovered(reserveUsd, parentAccountScope);
+		this.childrenOf.set(parentAccountScope, (this.childrenOf.get(parentAccountScope) ?? 0) + 1);
+		this.admittedTotal += 1;
+	}
+};
 //#endregion
 //#region src/model/profile-card.ts
 function toolNamesOf(profile) {
@@ -18708,6 +19094,7 @@ function createCtx(internals, rootWorkflow) {
 				agentType,
 				role: primaryRole,
 				budgetAccount: state.budgetScope ?? "run",
+				...opts.label === void 0 ? {} : { label: opts.label },
 				...opts[kFinalizeReserve] === true ? { finalizeReserve: true } : {}
 			},
 			transcriptRef: result.transcriptRef
@@ -21106,6 +21493,8 @@ function pairDraftClaims(draftText, rows, options) {
 	const max = requirePositiveInteger(options?.max ?? 40, "pairDraftClaims max");
 	const maxPoolPerPair = requirePositiveInteger(options?.maxPoolPerPair ?? 3, "pairDraftClaims maxPoolPerPair");
 	const maxExcerptChars = requirePositiveInteger(options?.maxExcerptChars ?? 400, "pairDraftClaims maxExcerptChars");
+	const targetShare = options?.targetCoverageShare;
+	if (targetShare !== void 0 && (typeof targetShare !== "number" || !Number.isFinite(targetShare) || targetShare <= 0 || targetShare > 1)) throw new ConfigError(`pairDraftClaims targetCoverageShare must be a number in (0, 1]; got ` + JSON.stringify(targetShare));
 	const poolByPath = /* @__PURE__ */ new Map();
 	for (const row of rows) for (const sentence of sentencesOf(row.text)) {
 		const anchors = anchorsOf(sentence, pattern);
@@ -21197,13 +21586,37 @@ function pairDraftClaims(draftText, rows, options) {
 			});
 		}
 	}
-	const reported = (critical === void 0 ? candidates : [...candidates.filter((candidate) => candidate.critical), ...candidates.filter((candidate) => !candidate.critical)]).slice(0, max);
+	const ordered = critical === void 0 ? candidates : [...candidates.filter((candidate) => candidate.critical), ...candidates.filter((candidate) => !candidate.critical)];
+	let reported;
+	let maxCut;
+	let targetSentences;
+	if (targetShare === void 0) {
+		reported = ordered.slice(0, max);
+		maxCut = candidates.length > reported.length;
+	} else {
+		targetSentences = Math.min(draftCitingSentences, Math.ceil(targetShare * draftCitingSentences));
+		const covering = /* @__PURE__ */ new Set();
+		const wanted = [];
+		for (const candidate of ordered) {
+			if (candidate.critical) {
+				wanted.push(candidate);
+				covering.add(candidate.sentence);
+				continue;
+			}
+			if (covering.size >= targetSentences || covering.has(candidate.sentence)) continue;
+			wanted.push(candidate);
+			covering.add(candidate.sentence);
+		}
+		reported = wanted.slice(0, max);
+		maxCut = wanted.length > reported.length;
+	}
 	const coveredSentences = new Set(reported.map((candidate) => candidate.sentence));
 	const fold = {
 		pairs: reported.map((candidate) => candidate.pair),
-		truncated: candidates.length > reported.length,
+		truncated: maxCut,
 		draftCitingSentences,
-		coveredCitingSentences: coveredSentences.size
+		coveredCitingSentences: coveredSentences.size,
+		...targetSentences === void 0 ? {} : { targetCoveredSentences: targetSentences }
 	};
 	if (critical !== void 0) {
 		const reportedAnchors = new Set(reported.map((candidate) => candidate.pair.anchor));
@@ -22010,10 +22423,14 @@ function validateOrchestrateOptions(opts) {
 			if (consistency.runFacts !== true) throw new ConfigError("orchestrate claimConsistency.runFactTerms rides the runFacts pass; set claimConsistency.runFacts true");
 			if (!Array.isArray(consistency.runFactTerms) || consistency.runFactTerms.some((term) => typeof term !== "string" || term.length === 0)) throw new ConfigError("orchestrate claimConsistency.runFactTerms must be an array of nonempty strings; got " + JSON.stringify(consistency.runFactTerms));
 		}
-		for (const [label, ratio] of [["minimumCoverageRatio", consistency.minimumCoverageRatio], ["runFactCoverageRatio", consistency.runFactCoverageRatio]]) if (ratio !== void 0 && (typeof ratio !== "number" || !Number.isFinite(ratio) || ratio <= 0 || ratio > 1)) throw new ConfigError(`orchestrate claimConsistency.${label} must be a number in (0, 1]; got ` + JSON.stringify(ratio));
+		for (const [label, ratio] of [
+			["minimumCoverageRatio", consistency.minimumCoverageRatio],
+			["runFactCoverageRatio", consistency.runFactCoverageRatio],
+			["coverageTarget", consistency.coverageTarget]
+		]) if (ratio !== void 0 && (typeof ratio !== "number" || !Number.isFinite(ratio) || ratio <= 0 || ratio > 1)) throw new ConfigError(`orchestrate claimConsistency.${label} must be a number in (0, 1]; got ` + JSON.stringify(ratio));
 		if (consistency.runFactCoverageRatio !== void 0 && consistency.runFacts !== true) throw new ConfigError("orchestrate claimConsistency.runFactCoverageRatio rides the runFacts pass; set claimConsistency.runFacts true");
 		if (consistency.onLowCoverage !== void 0 && consistency.onLowCoverage !== "report" && consistency.onLowCoverage !== "fail") throw new ConfigError("orchestrate claimConsistency.onLowCoverage must be 'report' or 'fail'; got " + JSON.stringify(consistency.onLowCoverage));
-		if (consistency.onLowCoverage !== void 0 && consistency.minimumCoverageRatio === void 0 && consistency.runFactCoverageRatio === void 0) throw new ConfigError("orchestrate claimConsistency.onLowCoverage needs a declared floor; set minimumCoverageRatio or runFactCoverageRatio");
+		if (consistency.onLowCoverage !== void 0 && consistency.minimumCoverageRatio === void 0 && consistency.runFactCoverageRatio === void 0 && consistency.coverageTarget === void 0) throw new ConfigError("orchestrate claimConsistency.onLowCoverage needs a declared floor; set minimumCoverageRatio, runFactCoverageRatio, or coverageTarget");
 		if (consistency.judge !== void 0) {
 			const judge = consistency.judge;
 			if (typeof judge !== "object" || judge === null || Array.isArray(judge)) throw new ConfigError(`orchestrate claimConsistency.judge must be an object; got ${JSON.stringify(consistency.judge)}`);
@@ -23685,6 +24102,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const noteOpts = {
 				role: "synthesize",
 				result: "full",
+				label: SYNTHESIS_NOTE_LABEL,
 				tools: finishOnly,
 				limits: spec.noteLimits ?? { maxTurns: 2 },
 				...spec.model === void 0 ? {} : { model: spec.model },
@@ -24021,7 +24439,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 				max: spec.max ?? 40,
 				...spec.maxPoolPerPair === void 0 ? {} : { maxPoolPerPair: spec.maxPoolPerPair },
 				...spec.maxExcerptChars === void 0 ? {} : { maxExcerptChars: spec.maxExcerptChars },
-				...spec.critical === void 0 ? {} : { critical: spec.critical }
+				...spec.critical === void 0 ? {} : { critical: spec.critical },
+				...spec.coverageTarget === void 0 ? {} : { targetCoverageShare: spec.coverageTarget }
 			});
 			const runFold = spec.runFacts === true ? pairRunFactClaims(draftText, {
 				text: `The run ${internals.runId} made ${String(factWires)} provider wire requests across ${String(poolChildren)} accepted children, with token totals ${String(factInput)} input and ${String(factOutput)} output (the run's own recorded execution facts; harness-observed, not production evidence). ${factRows.join(" ")}`,
@@ -24034,7 +24453,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 				]
 			}, {
 				...spec.runFactTerms === void 0 ? {} : { terms: spec.runFactTerms },
-				...spec.maxExcerptChars === void 0 ? {} : { maxExcerptChars: spec.maxExcerptChars }
+				...spec.maxExcerptChars === void 0 ? {} : { maxExcerptChars: spec.maxExcerptChars },
+				...spec.coverageTarget === void 0 ? {} : { max: Number.MAX_SAFE_INTEGER }
 			}) : void 0;
 			const allPairs = runFold === void 0 ? fold.pairs : [...fold.pairs, ...runFold.pairs];
 			const onFound = spec.onFound ?? "report";
@@ -24044,6 +24464,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				pairs: allPairs.length,
 				truncated: fold.truncated,
 				coveredCitingSentences: fold.coveredCitingSentences,
+				...spec.coverageTarget === void 0 ? {} : { coverageTarget: spec.coverageTarget },
 				...fold.criticalUncovered === void 0 ? {} : {
 					criticalUncovered: fold.criticalUncovered,
 					criticalUncoveredTotal: fold.criticalUncoveredTotal ?? 0
@@ -24054,14 +24475,15 @@ function makeOrchestratorWorkflow(goal, opts) {
 					runFactCandidates: runFold.candidates
 				},
 				...(() => {
+					const coverageFloor = spec.minimumCoverageRatio ?? spec.coverageTarget;
 					const coverageRatio = fold.draftCitingSentences === 0 ? 1 : fold.coveredCitingSentences / fold.draftCitingSentences;
 					const runFactRatio = runFold === void 0 || runFold.candidates === 0 ? void 0 : runFold.pairs.length / runFold.candidates;
-					const belowCoverage = spec.minimumCoverageRatio !== void 0 && fold.draftCitingSentences > 0 && coverageRatio < spec.minimumCoverageRatio;
+					const belowCoverage = coverageFloor !== void 0 && fold.draftCitingSentences > 0 && coverageRatio < coverageFloor;
 					const belowRunFacts = spec.runFactCoverageRatio !== void 0 && runFactRatio !== void 0 && runFactRatio < spec.runFactCoverageRatio;
 					if (!belowCoverage && !belowRunFacts) return {};
 					return { lowCoverage: {
 						coverageRatio,
-						...spec.minimumCoverageRatio === void 0 ? {} : { coverageFloor: spec.minimumCoverageRatio },
+						...coverageFloor === void 0 ? {} : { coverageFloor },
 						...runFactRatio === void 0 ? {} : { runFactRatio },
 						...spec.runFactCoverageRatio === void 0 ? {} : { runFactFloor: spec.runFactCoverageRatio }
 					} };
@@ -24558,6 +24980,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const synthesisOpts = {
 				role: "synthesize",
 				result: "full",
+				label: FINAL_COMPOSITION_LABEL,
 				tools: synthesisTools,
 				[kExposureWait]: true,
 				limits: spec.limits ?? { maxTurns: 4 },
@@ -28316,4 +28739,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };