@tangle-network/agent-eval 0.145.3 → 0.145.5

package/dist/{campaign-C5kujyqv.js → campaign-DGWSftLe.js}

@@ -1,20 +1,20 @@
 import { s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
-import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-Bgph_Qj-.js";
+import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-B_-TW9o0.js";
 import { buildAgentProfileCell } from "./profile-cell.js";
 import { t as comparePairedArms } from "./paired-arms-D-XRF_fy.js";
 import { r as pairedBootstrap } from "./paired-tests-BHIhYVdu.js";
 import { o as runTaskScore, r as modelHasSnapshot, s as validateRunRecord } from "./run-record-BvHPVS-i.js";
-import { n as contentHash } from "./verdict-cache-mZf5FEiY.js";
-import { K as runCampaign, Q as summarizeBackendIntegrity, Z as assertRealBackend, h as labelTrustRank, k as surfaceContentHash, q as planCampaignRun, w as assertCodeSurfaceIdentity } from "./llm-judge-C2lQBv7h.js";
-import { l as campaignCellToRunRecord } from "./reward-hacking-DNgjilrV.js";
+import { n as contentHash, t as canonicalJson } from "./verdict-cache-mZf5FEiY.js";
+import { $ as assertCampaignDesign, J as resolveRunDir, K as runCampaign, Q as summarizeBackendIntegrity, Z as assertRealBackend, at as computeManifestHash, h as labelTrustRank, it as cellCachePath, k as surfaceContentHash, q as planCampaignRun, tt as campaignScenarioIdentity, w as assertCodeSurfaceIdentity } from "./llm-judge-BPKBdQTp.js";
+import { a as campaignCellCostProvenance, l as campaignCellToRunRecord, u as projectCampaignCellQuality } from "./reward-hacking-DNgjilrV.js";
 import { t as CostAccountingIncompleteError } from "./cost-ledger-BSe92yAV.js";
 import { t as FileLedgerJournal, u as mapConcurrent } from "./ledger-core-BmZt19oQ.js";
 import { r as canonicalString } from "./canonical-D-XsTQ6_.js";
-import { C as SEARCH_LEDGER_FILE_CONTEXT, E as SearchLedgerIntegrityError, T as SearchLedgerError, w as SearchLedgerConflictError } from "./external-optimizer-subprocess-BhKYK0Jv.js";
+import { C as SEARCH_LEDGER_FILE_CONTEXT, E as SearchLedgerIntegrityError, T as SearchLedgerError, w as SearchLedgerConflictError, x as fsCampaignStorage } from "./external-optimizer-subprocess-BhKYK0Jv.js";
 import { o as pairHoldout } from "./power-preflight-DEw-uC7q.js";
 import { a as scoreAnalystFindings } from "./benchmark-BhT16ep9.js";
 import "./external-optimizer-process-BRE56woM.js";
-import "./skillopt-optimization-method-B__Jnto4.js";
+import "./skillopt-optimization-method-S7sdjzvh.js";
 import { createHash } from "node:crypto";
 import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { z } from "zod";
@@ -1490,6 +1490,45 @@ var ProfileMatrixError = class extends AgentEvalError {
 		super("profile_matrix", message);
 	}
 };
+/**
+* Return the exact per-profile campaign identity used by `runProfileMatrix`.
+* Segmented profile matrices use this to validate durable cell caches before
+* finalization without dispatching a probe request.
+*/
+function profileMatrixCampaignIdentity(opts) {
+	const seed = opts.seed ?? 42;
+	const splitTag = opts.splitTag ?? "search";
+	const reps = opts.reps ?? 1;
+	const profileHash = agentProfileHash(opts.profile);
+	const profileId = agentProfileId(opts.profile);
+	const configHash = sha({
+		profile: profileHash,
+		judges: (opts.judges ?? []).map((judge) => judge.name),
+		seed,
+		splitTag,
+		dispatchRef: opts.dispatchRef ?? null
+	});
+	const dispatchRef = `profile-matrix:${sha({
+		commitSha: opts.commitSha,
+		caller: opts.dispatchRef ?? null,
+		profileId,
+		profileHash,
+		configHash
+	})}`;
+	return {
+		profileHash,
+		profileId,
+		configHash,
+		dispatchRef,
+		manifestHash: computeManifestHash({
+			scenarios: opts.scenarios,
+			judges: opts.judges ?? [],
+			dispatchRef,
+			seed,
+			reps
+		})
+	};
+}
 function sanitize(id) {
 	return id.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
@@ -1565,7 +1604,7 @@ async function runProfileMatrix(opts) {
 		profileIds,
 		scenarios: opts.scenarios.map((s) => s.id)
 	}).slice(0, 16)}`;
-	const matrixId = `mtx_${sha({
+	const derivedMatrixId = `mtx_${sha({
 		experimentId,
 		profileIds,
 		seed,
@@ -1573,6 +1612,8 @@ async function runProfileMatrix(opts) {
 		commitSha: opts.commitSha,
 		dispatchRef: opts.dispatchRef ?? null
 	}).slice(0, 16)}`;
+	const matrixId = opts.matrixId ?? derivedMatrixId;
+	if (typeof matrixId !== "string" || matrixId.trim().length === 0) throw new ProfileMatrixError("matrixId must be a non-empty string when provided");
 	const scenarioById = new Map(opts.scenarios.map((s) => [s.id, s]));
 	for (const profile of opts.profiles) {
 		const profileHash = agentProfileHash(profile);
@@ -1612,23 +1653,17 @@ async function runProfileMatrix(opts) {
 	const campaigns = {};
 	const byProfile = {};
 	const columns = await mapConcurrent(opts.profiles, maxProfileConcurrency, async (profile, _index, signal) => {
-		const profileHash = agentProfileHash(profile);
-		const profileId = agentProfileId(profile);
-		const declaredModel = agentProfileModelId(profile);
-		const configHash = sha({
-			profile: profileHash,
-			judges: (opts.judges ?? []).map((j) => j.name),
-			seed,
+		const { profileHash, profileId, configHash, dispatchRef } = profileMatrixCampaignIdentity({
+			profile,
+			scenarios: opts.scenarios,
+			judges: opts.judges,
+			commitSha: opts.commitSha,
+			dispatchRef: opts.dispatchRef,
 			splitTag,
-			dispatchRef: opts.dispatchRef ?? null
+			seed,
+			reps: opts.reps
 		});
-		const dispatchRef = `profile-matrix:${sha({
-			commitSha: opts.commitSha,
-			caller: opts.dispatchRef ?? null,
-			profileId,
-			profileHash,
-			configHash
-		})}`;
+		const declaredModel = agentProfileModelId(profile);
 		const dispatch = (scenario, ctx) => opts.dispatch(profile, scenario, ctx);
 		Object.defineProperty(dispatch, "name", { value: `profile_${sanitize(profileId)}` });
 		const campaign = await runCampaign({
@@ -1641,6 +1676,12 @@ async function runProfileMatrix(opts) {
 			reps: opts.reps,
 			maxConcurrency: opts.maxConcurrency,
 			costCeiling: opts.costCeiling,
+			cellFilter: opts.rowFilter ? ({ scenario, rep }) => opts.rowFilter?.({
+				profile,
+				scenario,
+				rep
+			}) ?? false : void 0,
+			reuseFailedCells: opts.reuseFailedCells,
 			labeledStore: opts.labeledStore,
 			captureSource: opts.captureSource,
 			storage: opts.storage,
@@ -1749,6 +1790,444 @@ function rollupByPersona(records, scenarios, personaOf) {
 	return rollup(records, (r) => r.scenarioId ? personaByScenarioId.get(r.scenarioId) : void 0);
 }
 //#endregion
+//#region src/campaign/presets/segmented-profile-matrix.ts
+/**
+* Eval-owned execution for profile matrices whose external authorization is
+* shorter than the complete matrix.
+*
+* A plan freezes the complete profile × scenario × replicate design. A
+* segment claims an explicit, disjoint set of rows and uses the campaign cell
+* cache as the durable per-cell record. Finalization first checks that every
+* planned row has one claim and one valid record, then replays the ordinary
+* `runProfileMatrix` projection from those records without dispatching work.
+*/
+const PLAN_FILE = "profile-matrix-plan.json";
+const SEGMENTS_FILE = "profile-matrix-segments.jsonl";
+var SegmentedProfileMatrixError = class extends ProfileMatrixError {
+	constructor(message) {
+		super(`segmented matrix: ${message}`);
+	}
+};
+function createProfileMatrixPlan(opts) {
+	if (!Array.isArray(opts.profiles) || opts.profiles.length === 0) throw new SegmentedProfileMatrixError("profiles must not be empty");
+	if (!Array.isArray(opts.scenarios) || opts.scenarios.length === 0) throw new SegmentedProfileMatrixError("scenarios must not be empty");
+	const reps = opts.reps ?? 1;
+	const seed = opts.seed ?? 42;
+	const splitTag = opts.splitTag ?? "search";
+	const integrity = opts.integrity ?? "assert";
+	const allowMixed = opts.allowMixed ?? true;
+	const validate = opts.validate ?? true;
+	if (typeof opts.commitSha !== "string" || opts.commitSha.trim().length === 0) throw new SegmentedProfileMatrixError("commitSha must be a non-empty string");
+	if (typeof opts.dispatchRef !== "string" || opts.dispatchRef.trim().length === 0) throw new SegmentedProfileMatrixError("dispatchRef must be a non-empty stable identity for segmented execution");
+	assertCampaignDesign(opts.scenarios, reps);
+	const profiles = [...opts.profiles];
+	const scenarios = [...opts.scenarios];
+	const judges = [...opts.judges ?? []];
+	const profileIds = profiles.map(agentProfileId);
+	const duplicateProfiles = profileIds.filter((id, index) => profileIds.indexOf(id) !== index);
+	if (duplicateProfiles.length > 0) throw new SegmentedProfileMatrixError(`duplicate profile ids: ${[...new Set(duplicateProfiles)].join(", ")}`);
+	const experimentId = opts.experimentId ?? `pm_${contentHash({
+		profileIds,
+		scenarios: scenarios.map((scenario) => scenario.id)
+	}).slice(0, 16)}`;
+	if (experimentId.trim().length === 0) throw new SegmentedProfileMatrixError("experimentId must be non-empty");
+	const planDigest = `sha256:${contentHash({
+		schema: "tangle.profile-matrix-plan.v1",
+		profiles: profiles.map((profile, index) => ({
+			ordinal: index,
+			id: profileIds[index],
+			hash: `sha256:${agentProfileHash(profile)}`,
+			profile
+		})),
+		scenarios: scenarios.map((scenario, index) => ({
+			ordinal: index,
+			identity: campaignScenarioIdentity(scenario),
+			scenario
+		})),
+		judges: judges.map((judge) => ({
+			name: judge.name,
+			dimensions: judge.dimensions,
+			judgeVersion: judge.judgeVersion ?? null,
+			score: judge.score.toString(),
+			appliesTo: judge.appliesTo?.toString() ?? null
+		})),
+		reps,
+		seed,
+		splitTag,
+		commitSha: opts.commitSha,
+		dispatchRef: opts.dispatchRef,
+		experimentId,
+		integrity,
+		allowMixed,
+		validate,
+		personaOf: opts.personaOf?.toString() ?? null,
+		corpusText: opts.corpusText?.toString() ?? null
+	})}`;
+	const matrixId = `pmx_${planDigest.slice(7, 31)}`;
+	const rows = [];
+	const seenCellIds = /* @__PURE__ */ new Set();
+	let ordinal = 0;
+	for (const profileId of profileIds) for (const scenario of scenarios) for (let rep = 0; rep < reps; rep += 1) {
+		const cellId = `${scenario.id}:${rep}`;
+		if (seenCellIds.has(`${profileId}:${cellId}`)) throw new SegmentedProfileMatrixError(`profile/scenario/rep cell id collision for '${profileId}:${cellId}'`);
+		seenCellIds.add(`${profileId}:${cellId}`);
+		rows.push({
+			rowId: `row_${contentHash({
+				matrixId,
+				profileId,
+				scenarioId: scenario.id,
+				rep
+			}).slice(0, 24)}`,
+			ordinal,
+			profileId,
+			scenarioId: scenario.id,
+			rep
+		});
+		ordinal += 1;
+	}
+	return Object.freeze({
+		schemaVersion: 1,
+		matrixId,
+		experimentId,
+		planDigest,
+		profiles: Object.freeze(profiles),
+		scenarios: Object.freeze(scenarios),
+		judges: Object.freeze(judges),
+		reps,
+		seed,
+		splitTag,
+		commitSha: opts.commitSha,
+		dispatchRef: opts.dispatchRef,
+		integrity,
+		allowMixed,
+		validate,
+		...opts.personaOf === void 0 ? {} : { personaOf: opts.personaOf },
+		...opts.corpusText === void 0 ? {} : { corpusText: opts.corpusText },
+		rows: Object.freeze(rows)
+	});
+}
+async function runProfileMatrixSegment(opts) {
+	const segmentId = requireIdentifier(opts.segmentId, "segmentId");
+	const storage = opts.storage ?? fsCampaignStorage();
+	const runDir = resolveRunDir(opts.runDir);
+	assertPlan(opts.plan);
+	const selected = normalizeRows(opts.plan, opts.rows);
+	ensureManifest(storage, runDir, manifestFor(opts.plan));
+	claimSegment(storage, runDir, opts.plan, segmentId, selected);
+	const selectedIds = new Set(selected.map((row) => row.rowId));
+	const selectedProfileIds = new Set(selected.map((row) => row.profileId));
+	const matrix = await runProfileMatrix({
+		profiles: opts.plan.profiles.filter((profile) => selectedProfileIds.has(agentProfileId(profile))),
+		scenarios: [...opts.plan.scenarios],
+		dispatch: opts.dispatch,
+		judges: [...opts.plan.judges],
+		runDir,
+		commitSha: opts.plan.commitSha,
+		dispatchRef: opts.plan.dispatchRef,
+		experimentId: opts.plan.experimentId,
+		matrixId: opts.plan.matrixId,
+		splitTag: opts.plan.splitTag,
+		reps: opts.plan.reps,
+		seed: opts.plan.seed,
+		integrity: "off",
+		allowMixed: opts.plan.allowMixed,
+		maxConcurrency: opts.maxConcurrency,
+		maxProfileConcurrency: opts.maxProfileConcurrency,
+		costCeiling: opts.costCeiling,
+		labeledStore: opts.labeledStore,
+		captureSource: opts.captureSource,
+		storage,
+		now: opts.now,
+		personaOf: opts.plan.personaOf,
+		validate: opts.plan.validate,
+		corpusText: opts.plan.corpusText,
+		reuseFailedCells: false,
+		rowFilter: ({ profile, scenario, rep }) => selectedIds.has(rowIdFor(opts.plan, agentProfileId(profile), scenario.id, rep))
+	});
+	persistSegmentCells(storage, runDir, matrix);
+	const coverage = readCoverage(storage, runDir, opts.plan);
+	return {
+		segmentId,
+		rowIds: selected.map((row) => row.rowId),
+		matrix,
+		coverage
+	};
+}
+async function finalizeProfileMatrix(opts) {
+	const storage = opts.storage ?? fsCampaignStorage();
+	const runDir = resolveRunDir(opts.runDir);
+	assertPlan(opts.plan);
+	ensureManifest(storage, runDir, manifestFor(opts.plan));
+	const claims = readSegmentClaims(storage, runDir);
+	assertCompleteClaims(opts.plan, claims);
+	const coverage = readCoverage(storage, runDir, opts.plan);
+	if (coverage.missing.length > 0) throw new SegmentedProfileMatrixError(`cannot finalize with missing rows: ${coverage.missing.join(", ")}`);
+	const matrix = await runProfileMatrix({
+		profiles: [...opts.plan.profiles],
+		scenarios: [...opts.plan.scenarios],
+		dispatch: async () => {
+			throw new SegmentedProfileMatrixError("finalization attempted to dispatch an uncached row; the persisted coverage changed during finalization");
+		},
+		judges: [...opts.plan.judges],
+		runDir,
+		commitSha: opts.plan.commitSha,
+		dispatchRef: opts.plan.dispatchRef,
+		experimentId: opts.plan.experimentId,
+		matrixId: opts.plan.matrixId,
+		splitTag: opts.plan.splitTag,
+		reps: opts.plan.reps,
+		seed: opts.plan.seed,
+		integrity: opts.plan.integrity,
+		allowMixed: opts.plan.allowMixed,
+		maxConcurrency: opts.maxConcurrency,
+		maxProfileConcurrency: opts.maxProfileConcurrency,
+		storage,
+		now: opts.now,
+		personaOf: opts.plan.personaOf,
+		validate: opts.plan.validate,
+		corpusText: opts.plan.corpusText,
+		reuseFailedCells: true
+	});
+	assertFinalRows(opts.plan, matrix);
+	return {
+		...matrix,
+		coverage
+	};
+}
+function manifestFor(plan) {
+	return {
+		schemaVersion: 1,
+		matrixId: plan.matrixId,
+		experimentId: plan.experimentId,
+		planDigest: plan.planDigest,
+		profiles: plan.profiles.map((profile) => ({
+			id: agentProfileId(profile),
+			hash: `sha256:${agentProfileHash(profile)}`
+		})),
+		scenarios: plan.scenarios.map((scenario) => campaignScenarioIdentity(scenario)),
+		reps: plan.reps,
+		seed: plan.seed,
+		splitTag: plan.splitTag,
+		commitSha: plan.commitSha,
+		dispatchRef: plan.dispatchRef,
+		rows: [...plan.rows]
+	};
+}
+function assertPlan(plan) {
+	const rebuilt = createProfileMatrixPlan({
+		profiles: [...plan.profiles],
+		scenarios: [...plan.scenarios],
+		judges: [...plan.judges],
+		commitSha: plan.commitSha,
+		dispatchRef: plan.dispatchRef,
+		experimentId: plan.experimentId,
+		splitTag: plan.splitTag,
+		reps: plan.reps,
+		seed: plan.seed,
+		integrity: plan.integrity,
+		allowMixed: plan.allowMixed,
+		validate: plan.validate,
+		personaOf: plan.personaOf,
+		corpusText: plan.corpusText
+	});
+	if (rebuilt.planDigest !== plan.planDigest || rebuilt.matrixId !== plan.matrixId || canonicalJson(rebuilt.rows) !== canonicalJson(plan.rows)) throw new SegmentedProfileMatrixError("plan inputs changed after identity was created");
+}
+function ensureManifest(storage, runDir, expected) {
+	storage.ensureDir(runDir);
+	const path = join(runDir, PLAN_FILE);
+	if (storage.read(path) === void 0) {
+		const content = `${canonicalJson(expected)}\n`;
+		if (storage.append(path, content, 0) !== void 0) return;
+	}
+	const persisted = storage.read(path);
+	if (persisted === void 0) throw new SegmentedProfileMatrixError("persisted plan is unreadable");
+	let parsed;
+	try {
+		parsed = JSON.parse(persisted);
+	} catch {
+		throw new SegmentedProfileMatrixError("persisted plan is corrupt JSON");
+	}
+	if (canonicalJson(parsed) !== canonicalJson(expected)) throw new SegmentedProfileMatrixError("persisted plan identity does not match the supplied inputs");
+}
+function normalizeRows(plan, rows) {
+	if (!Array.isArray(rows) || rows.length === 0) throw new SegmentedProfileMatrixError("a segment must select at least one row");
+	const byId = new Map(plan.rows.map((row) => [row.rowId, row]));
+	const selected = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const input of rows) {
+		const rowId = typeof input === "string" ? input : input?.rowId;
+		if (typeof rowId !== "string" || rowId.length === 0) throw new SegmentedProfileMatrixError("segment rows must contain row ids");
+		if (seen.has(rowId)) throw new SegmentedProfileMatrixError(`duplicate row '${rowId}' in segment`);
+		const row = byId.get(rowId);
+		if (!row) throw new SegmentedProfileMatrixError(`row '${rowId}' is not declared by the plan`);
+		if (typeof input !== "string" && canonicalJson(input) !== canonicalJson(row)) throw new SegmentedProfileMatrixError(`row '${rowId}' does not match the declared plan row`);
+		seen.add(rowId);
+		selected.push(row);
+	}
+	return selected.sort((left, right) => left.ordinal - right.ordinal);
+}
+function claimSegment(storage, runDir, plan, segmentId, selected) {
+	const path = join(runDir, SEGMENTS_FILE);
+	const expected = canonicalJson({
+		schemaVersion: 1,
+		segmentId,
+		planDigest: plan.planDigest,
+		rowIds: selected.map((row) => row.rowId).sort()
+	});
+	for (let attempt = 0; attempt < 8; attempt += 1) {
+		const raw = storage.read(path) ?? "";
+		const claims = parseSegmentClaims(raw, path);
+		const existing = claims.find((claim) => claim.segmentId === segmentId);
+		if (existing) {
+			if (canonicalJson(existing) !== expected) throw new SegmentedProfileMatrixError(`segment '${segmentId}' was resumed with different rows or plan identity`);
+			return;
+		}
+		const selectedIds = new Set(selected.map((row) => row.rowId));
+		const overlap = claims.flatMap((claim) => claim.rowIds.filter((rowId) => selectedIds.has(rowId)).map((rowId) => `${rowId} (${claim.segmentId})`));
+		if (overlap.length > 0) throw new SegmentedProfileMatrixError(`segment rows overlap existing claims: ${overlap.join(", ")}`);
+		const event = `${expected}\n`;
+		if (storage.append(path, event, byteLength(raw)) !== void 0) return;
+	}
+	throw new SegmentedProfileMatrixError(`could not claim segment '${segmentId}' after concurrent updates`);
+}
+function readSegmentClaims(storage, runDir) {
+	const path = join(runDir, SEGMENTS_FILE);
+	const raw = storage.read(path);
+	if (raw === void 0) return [];
+	return parseSegmentClaims(raw, path);
+}
+function parseSegmentClaims(raw, path) {
+	const claims = [];
+	const seenSegments = /* @__PURE__ */ new Set();
+	const seenRows = /* @__PURE__ */ new Map();
+	for (const [index, line] of raw.split("\n").entries()) {
+		if (line.trim() === "") continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			throw new SegmentedProfileMatrixError(`segment registry is corrupt at ${path}:${index + 1}`);
+		}
+		if (canonicalJson(parsed) !== line) throw new SegmentedProfileMatrixError(`segment registry is not canonical at ${path}:${index + 1}`);
+		const claim = parsed;
+		if (claim.schemaVersion !== 1 || typeof claim.segmentId !== "string" || typeof claim.planDigest !== "string" || !Array.isArray(claim.rowIds) || claim.rowIds.some((rowId) => typeof rowId !== "string") || new Set(claim.rowIds).size !== claim.rowIds.length) throw new SegmentedProfileMatrixError(`segment registry has an invalid claim at ${path}:${index + 1}`);
+		if (seenSegments.has(claim.segmentId)) throw new SegmentedProfileMatrixError(`segment registry repeats segment '${claim.segmentId}'`);
+		seenSegments.add(claim.segmentId);
+		const normalized = {
+			schemaVersion: 1,
+			segmentId: claim.segmentId,
+			planDigest: claim.planDigest,
+			rowIds: [...claim.rowIds].sort()
+		};
+		for (const rowId of normalized.rowIds) {
+			const owner = seenRows.get(rowId);
+			if (owner) throw new SegmentedProfileMatrixError(`segment registry overlaps row '${rowId}' between '${owner}' and '${normalized.segmentId}'`);
+			seenRows.set(rowId, normalized.segmentId);
+		}
+		claims.push(normalized);
+	}
+	return claims;
+}
+function assertCompleteClaims(plan, claims) {
+	const expected = new Set(plan.rows.map((row) => row.rowId));
+	const claimed = /* @__PURE__ */ new Set();
+	for (const claim of claims) {
+		if (claim.planDigest !== plan.planDigest) throw new SegmentedProfileMatrixError(`segment '${claim.segmentId}' belongs to a different plan identity`);
+		for (const rowId of claim.rowIds) {
+			if (!expected.has(rowId)) throw new SegmentedProfileMatrixError(`segment '${claim.segmentId}' claims an undeclared row '${rowId}'`);
+			claimed.add(rowId);
+		}
+	}
+	const missingClaims = plan.rows.filter((row) => !claimed.has(row.rowId)).map((row) => row.rowId);
+	if (missingClaims.length > 0) throw new SegmentedProfileMatrixError(`cannot finalize until every row is claimed: ${missingClaims.join(", ")}`);
+}
+function persistSegmentCells(storage, runDir, matrix) {
+	for (const [profileId, campaign] of Object.entries(matrix.campaigns)) for (const cell of campaign.cells) {
+		const path = cellCachePath(join(runDir, profileDirectory(profileId)), cell.cellId);
+		storage.ensureDir(dirname(path));
+		storage.write(path, `${JSON.stringify(cell)}\n`);
+	}
+}
+function readCoverage(storage, runDir, plan) {
+	const expectedManifestHashes = new Map(plan.profiles.map((profile) => {
+		const identity = profileMatrixCampaignIdentity({
+			profile,
+			scenarios: [...plan.scenarios],
+			judges: [...plan.judges],
+			commitSha: plan.commitSha,
+			dispatchRef: plan.dispatchRef,
+			splitTag: plan.splitTag,
+			seed: plan.seed,
+			reps: plan.reps
+		});
+		return [identity.profileId, identity.manifestHash];
+	}));
+	const missing = [];
+	const failed = [];
+	const zeroScore = [];
+	let present = 0;
+	for (const row of plan.rows) {
+		const path = cellCachePath(join(runDir, profileDirectory(row.profileId)), `${row.scenarioId}:${row.rep}`);
+		const raw = storage.read(path);
+		if (raw === void 0) {
+			missing.push(row.rowId);
+			continue;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			throw new SegmentedProfileMatrixError(`cell '${row.rowId}' has corrupt JSON`);
+		}
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new SegmentedProfileMatrixError(`cell '${row.rowId}' has an invalid record shape`);
+		const cell = parsed;
+		if (cell.cellId !== `${row.scenarioId}:${row.rep}` || cell.scenarioId !== row.scenarioId || cell.rep !== row.rep || cell.manifestHash !== expectedManifestHashes.get(row.profileId)) throw new SegmentedProfileMatrixError(`cell '${row.rowId}' has stale identity fields (manifest or row identity)`);
+		try {
+			campaignCellCostProvenance(cell);
+		} catch (error) {
+			throw new SegmentedProfileMatrixError(`cell '${row.rowId}' failed cost-record validation: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		present += 1;
+		if (cell.error !== void 0) {
+			failed.push(row.rowId);
+			continue;
+		}
+		if (projectCampaignCellQuality(cell).score === 0) zeroScore.push(row.rowId);
+	}
+	return {
+		expected: plan.rows.length,
+		present,
+		missing,
+		failed,
+		zeroScore
+	};
+}
+function assertFinalRows(plan, matrix) {
+	const expected = new Set(plan.rows.map((row) => `${row.profileId}:${row.scenarioId}:${row.rep}`));
+	const seen = /* @__PURE__ */ new Set();
+	for (const record of matrix.records) {
+		const key = `${record.candidateId}:${record.scenarioId}:${record.outcome.raw.rep}`;
+		if (!expected.has(key) || seen.has(key)) throw new SegmentedProfileMatrixError(`final matrix has an unexpected or duplicate row '${key}'`);
+		seen.add(key);
+	}
+	if (seen.size !== expected.size) throw new SegmentedProfileMatrixError(`final matrix returned ${seen.size}/${expected.size} declared rows`);
+}
+function rowIdFor(plan, profileId, scenarioId, rep) {
+	const row = plan.rows.find((candidate) => candidate.profileId === profileId && candidate.scenarioId === scenarioId && candidate.rep === rep);
+	if (!row) throw new SegmentedProfileMatrixError(`row is not declared: ${profileId}/${scenarioId}/${rep}`);
+	return row.rowId;
+}
+function profileDirectory(profileId) {
+	return profileId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function requireIdentifier(value, name) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new SegmentedProfileMatrixError(`${name} must be a non-empty string`);
+	return value;
+}
+function byteLength(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+//#endregion
 //#region src/campaign/scenario-selection.ts
 const DEFAULT_SATURATION_CEILING = .999;
 /** Variance below this is treated as "every candidate scored the same". */
@@ -3177,6 +3656,6 @@ function resolveWorktreePath(surface, worktreeDir) {
 	return verifyCodeSurface(surface, worktreeDir).path;
 }
 //#endregion
-export { planEvalFixtureRun as A, LabeledScenarioStoreError as C, discoverEvalFixtures as D, neutralizationGate as E, buildTraceAnalystSurfaceDispatch as M, traceAnalystQualityJudge as N, loadEvalFixture as O, FsLabeledScenarioStore as S, rolloutArgumentDiff as T, renderScoreboardMarkdown as _, autoevalsScorerJudge as a, userStoryScoreboard as b, FileSearchLedger as c, validateSearchLedgerEvent as d, scoreDiscrimination as f, makePlaybackDispatch as g, runProfileMatrix as h, verifyCodeSurface as i, analyzeCrossSurfaceInteractions as j, loadEvalFixtureScenarios as k, SEARCH_LEDGER_SCHEMA as l, ProfileMatrixError as m, gitWorktreeAdapter as n, phoenixEvaluatorJudge as o, selectDiscriminative as p, resolveWorktreePath as r, isTransientTransportFailure as s, WorktreeAdapterError as t, openSearchLedger as u, scoreUserStory as v, classifyUngroundedLiterals as w, neutralizeText as x, scoreboardSummary as y };
+export { neutralizationGate as A, scoreboardSummary as C, LabeledScenarioStoreError as D, FsLabeledScenarioStore as E, analyzeCrossSurfaceInteractions as F, buildTraceAnalystSurfaceDispatch as I, traceAnalystQualityJudge as L, loadEvalFixture as M, loadEvalFixtureScenarios as N, classifyUngroundedLiterals as O, planEvalFixtureRun as P, scoreUserStory as S, neutralizeText as T, runProfileMatrixSegment as _, autoevalsScorerJudge as a, makePlaybackDispatch as b, FileSearchLedger as c, validateSearchLedgerEvent as d, scoreDiscrimination as f, finalizeProfileMatrix as g, createProfileMatrixPlan as h, verifyCodeSurface as i, discoverEvalFixtures as j, rolloutArgumentDiff as k, SEARCH_LEDGER_SCHEMA as l, SegmentedProfileMatrixError as m, gitWorktreeAdapter as n, phoenixEvaluatorJudge as o, selectDiscriminative as p, resolveWorktreePath as r, isTransientTransportFailure as s, WorktreeAdapterError as t, openSearchLedger as u, ProfileMatrixError as v, userStoryScoreboard as w, renderScoreboardMarkdown as x, runProfileMatrix as y };
 
-//# sourceMappingURL=campaign-C5kujyqv.js.map
+//# sourceMappingURL=campaign-DGWSftLe.js.map