@tangle-network/agent-eval 0.150.1 → 0.161.0

package/dist/{campaign-CN_7xJdV.js → campaign-BSmOwskD.js}

@@ -1,24 +1,23 @@
 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-jfk8Du3b.js";
+import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-DZ89riy5.js";
 import { buildAgentProfileCell } from "./profile-cell.js";
+import { c as mulberry32 } from "./internal-BDHPCnjk.js";
 import { t as comparePairedArms } from "./paired-arms-D-XRF_fy.js";
 import { r as pairedBootstrap } from "./paired-tests-BHIhYVdu.js";
-import { c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, s as runTaskScore } from "./run-record-D2lDdSAz.js";
-import { n as contentHash, t as canonicalJson } from "./verdict-cache-mZf5FEiY.js";
-import { at as assertRealBackend, et as runCampaign, h as labelTrustRank, k as surfaceContentHash, lt as campaignScenarioIdentity, mt as computeManifestHash, nt as resolveRunDir, ot as summarizeBackendIntegrity, pt as cellCachePath, st as assertCampaignDesign, tt as planCampaignRun, w as assertCodeSurfaceIdentity } from "./llm-judge-CVq33oz1.js";
-import { a as campaignCellCostProvenance, l as campaignCellToRunRecord, u as projectCampaignCellQuality } from "./reward-hacking-DKI9T52l.js";
+import { c as validateRunRecord, i as modelHasSnapshot, n as UNKNOWN_MODEL, s as runTaskScore } from "./run-record-BC0ebuRP.js";
+import { n as contentHash, t as canonicalJson } from "./verdict-cache-CdVVTVmn.js";
+import { N as surfaceContentHash, S as paretoFrontierWithCrowding, _ as labelTrustRank, ct as summarizeBackendIntegrity, dt as campaignScenarioIdentity, gt as computeManifestHash, ht as cellCachePath, it as resolveRunDir, k as assertCodeSurfaceIdentity, lt as assertCampaignDesign, nt as runCampaign, rt as planCampaignRun, st as assertRealBackend } from "./llm-judge-BhasIPFT.js";
+import { a as campaignCellCostProvenance, l as campaignCellToRunRecord, u as projectCampaignCellQuality } from "./reward-hacking-t4lB1yt8.js";
 import { t as CostAccountingIncompleteError } from "./cost-ledger-B1qx30B4.js";
-import { t as FileLedgerJournal, u as mapConcurrent } from "./ledger-core-DTae9rv_.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, x as fsCampaignStorage } from "./external-optimizer-subprocess-Dn90UqN2.js";
+import { u as mapConcurrent } from "./ledger-core-BOzlRygb.js";
+import { x as fsCampaignStorage } from "./external-optimizer-subprocess-BIWbHpgD.js";
 import { o as pairHoldout } from "./power-preflight-DEw-uC7q.js";
-import { l as costReceiptFromLlm, s as callLlm, u as costReceiptFromLlmError } from "./llm-client-Bg32RW0j.js";
 import { a as scoreAnalystFindings } from "./benchmark-BhT16ep9.js";
-import "./external-optimizer-process-Bhmzngf-.js";
-import "./skillopt-optimization-method-DLeUcK-K.js";
+import "./external-optimizer-process-WosTBChy.js";
+import "./skillopt-optimization-method-DbaekMcn.js";
+import "./sequential-rYW-Ophm.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";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { devNull, tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
@@ -210,7 +209,7 @@ function validateCandidate(candidate, componentById, componentIndex, baselineCan
 	assertNonEmpty(candidate.candidateId, "candidateId");
 	assertNonEmpty(candidate.contentHash, `contentHash for candidate '${candidate.candidateId}'`);
 	if (!Number.isInteger(candidate.artifactBytes) || candidate.artifactBytes < 0) throw new ValidationError(`analyzeCrossSurfaceInteractions: artifactBytes for candidate '${candidate.candidateId}' must be a non-negative integer`);
-	assertUnique$1(candidate.componentIds, `componentIds for candidate '${candidate.candidateId}'`);
+	assertUnique(candidate.componentIds, `componentIds for candidate '${candidate.candidateId}'`);
 	for (const componentId of candidate.componentIds) if (!componentById.has(componentId)) throw new ValidationError(`analyzeCrossSurfaceInteractions: candidate '${candidate.candidateId}' names unknown component '${componentId}'`);
 	const canonical = [...candidate.componentIds].sort((left, right) => componentIndex.get(left) - componentIndex.get(right));
 	if (!arraysEqual(candidate.componentIds, canonical)) throw new ValidationError(`analyzeCrossSurfaceInteractions: candidate '${candidate.candidateId}' components must follow componentOrder`);
@@ -258,10 +257,10 @@ function indexUnique(items, id, label) {
 }
 function assertNonEmptyUnique(values, label) {
 	if (values.length === 0) throw new ValidationError(`analyzeCrossSurfaceInteractions: ${label} is empty`);
-	assertUnique$1(values, label);
+	assertUnique(values, label);
 	for (const value of values) assertNonEmpty(value, label);
 }
-function assertUnique$1(values, label) {
+function assertUnique(values, label) {
 	if (new Set(values).size !== values.length) throw new ValidationError(`analyzeCrossSurfaceInteractions: ${label} contains duplicates`);
 }
 function assertNonEmpty(value, label) {
@@ -1334,86 +1333,72 @@ function neutralizeText(content) {
 	return content.replace(/\S/g, FILLER);
 }
 //#endregion
-//#region src/campaign/openai-compatible-execution-owner.ts
+//#region src/campaign/parent-selection.ts
 /**
-* Execution owner for the metered optimizer-model path, backed by any
-* OpenAI-compatible `/chat/completions` endpoint.
+* Parent selection for `runOptimization`.
 *
-* The loopback proxy owns admission, budgets, identity checks, and
-* cost-ledger recording. This owner only executes the exact admitted
-* request and resolves with a typed outcome: a canonical response plus a
-* JSON-clean receipt on success, or a public error plus an honest receipt
-* on failure. It never rejects, because a rejection loses the execution
-* record and fails the optimizer attempt.
-*
-* Canonical `tools`/`toolChoice` pass through to the wire as
-* `tools`/`tool_choice`; response `tool_calls` come back as canonical
-* `toolCalls`. A response that carries none when tools were sent is a valid
-* model answer, not an error.
+* Each generation mutates one parent surface. The default parent is the
+* global incumbent, so the search is a hill-climb and the lineage recorded in
+* `GenerationCandidate.parentSurfaceHash` is a chain. A `ParentSelector` draws
+* the parent from the Pareto frontier instead, so the recorded lineage becomes
+* a tree. Promotion is unchanged: a candidate still has to beat the incumbent.
 */
-function createOpenAiCompatibleExecutionOwner(options) {
-	for (const field of [
-		"baseUrl",
-		"apiKey",
-		"model"
-	]) {
-		const value = options[field];
-		if (typeof value !== "string" || !value.trim() || value.trim() !== value) throw new Error(`createOpenAiCompatibleExecutionOwner: ${field} must be a trimmed, non-empty string`);
-	}
-	const { baseUrl, apiKey, model, pricing, timeoutMs, maximumAttempts, fetch: fetchImpl } = options;
-	return async ({ callId, request, signal }) => {
-		const transportRequest = structuredClone(request);
-		try {
-			const wireResponse = await callLlm(transportRequest, {
-				baseUrl,
-				apiKey,
-				signal,
-				idempotencyKey: callId,
-				maximumAttempts: maximumAttempts ?? 2,
-				...timeoutMs === void 0 ? {} : { defaultTimeoutMs: timeoutMs },
-				...pricing ? { customTokenPricing: pricing } : {},
-				...fetchImpl ? { fetch: fetchImpl } : {}
-			});
-			const response = wireResponse.finishReason === "tool_calls" ? {
-				...wireResponse,
-				finishReason: "tool_use"
-			} : wireResponse;
-			return {
-				succeeded: true,
-				response,
-				receipt: costReceiptFromLlm(response, pricing),
-				execution: {
-					owner: "openai-compatible",
-					endpoint: baseUrl,
-					model: response.model,
-					callId,
-					durationMs: response.durationMs
-				}
-			};
-		} catch (error) {
-			const cause = error instanceof Error ? error : new Error(String(error));
-			const receipt = costReceiptFromLlmError(cause, pricing) ?? {
-				model,
-				inputTokens: 0,
-				outputTokens: 0,
-				costUnknown: true,
-				usageUnknown: true
-			};
-			return {
-				succeeded: false,
-				error: cause.message,
-				receipt,
-				execution: {
-					owner: "openai-compatible",
-					endpoint: baseUrl,
-					model,
-					callId,
-					failed: true
-				}
-			};
-		}
+/**
+* NSGA-II crowded tournament selection over the frontier. Each generation
+* draws two distinct frontier members with a PRNG seeded from `seed` and the
+* generation index, and keeps the one with the larger crowding distance (more
+* isolated on the frontier). Boundary parents carry infinite distance, so a
+* boundary parent always beats an interior one. A tie on distance falls back
+* to the higher mean composite, then to the smaller surface hash. A frontier
+* of one member returns that member.
+*/
+function crowdedFrontierParent(options) {
+	const { seed } = options;
+	if (!Number.isInteger(seed)) throw new TypeError(`crowdedFrontierParent: seed must be an integer, got ${String(seed)}`);
+	return ({ frontier, generation }) => {
+		if (frontier.length === 0) throw new Error("crowdedFrontierParent: frontier is empty");
+		if (frontier.length === 1) return frontier[0];
+		const distances = /* @__PURE__ */ new Map();
+		for (const { candidate, distance } of paretoFrontierWithCrowding([...frontier], frontierObjectives(frontier))) distances.set(candidate, distance);
+		const rng = mulberry32(tournamentSeed(seed, generation));
+		const first = Math.floor(rng() * frontier.length);
+		const offset = Math.floor(rng() * (frontier.length - 1));
+		const second = offset >= first ? offset + 1 : offset;
+		const a = frontier[first];
+		const b = frontier[second];
+		return compareCrowded(a, distanceOf(distances, a), b, distanceOf(distances, b)) <= 0 ? a : b;
 	};
 }
+function distanceOf(distances, parent) {
+	const distance = distances.get(parent);
+	if (distance === void 0) throw new Error(`crowdedFrontierParent: frontier member "${parent.surfaceHash}" is dominated or has a non-finite objective`);
+	return distance;
+}
+/** Negative when `a` wins the tournament, positive when `b` wins. */
+function compareCrowded(a, da, b, db) {
+	if (da !== db) return da > db ? -1 : 1;
+	if (a.composite !== b.composite) return a.composite > b.composite ? -1 : 1;
+	if (a.surfaceHash === b.surfaceHash) return 0;
+	return a.surfaceHash < b.surfaceHash ? -1 : 1;
+}
+/** One `maximize` objective per scenario id present on the frontier. */
+function frontierObjectives(frontier) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const parent of frontier) for (const id of Object.keys(parent.objectives)) ids.add(id);
+	if (ids.size === 0) throw new Error("crowdedFrontierParent: frontier parents carry no objectives");
+	return [...ids].sort().map((id) => ({
+		name: id,
+		direction: "maximize",
+		value: (parent) => {
+			const value = parent.objectives[id];
+			if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`crowdedFrontierParent: frontier member "${parent.surfaceHash}" has no finite objective "${id}"`);
+			return value;
+		}
+	}));
+}
+function tournamentSeed(seed, generation) {
+	return seed ^ Math.imul(generation + 1, 2654435761) | 0;
+}
 //#endregion
 //#region src/campaign/presets/playback.ts
 /**
@@ -2411,709 +2396,6 @@ function selectDiscriminative(signals, k, opts) {
 	return [...nonTied, ...fill].map((s) => s.scenarioId);
 }
 //#endregion
-//#region src/campaign/search-ledger.ts
-/**
-* Durable append-only audit log for improvement searches.
-*
-* Existing campaign artifacts keep their own rich records: `RunRecord` owns a
-* measured run and `CostLedger` owns per-call accounting. This ledger does not
-* copy those structures. It binds their immutable ids and receipts into one replayable event stream so a
-* search can answer, after a crash, exactly which candidates and task attempts
-* existed, which surfaces actually fired, what they cost, and why they were
-* selected or rejected.
-*
-* The file format is canonical JSONL with a SHA-256 hash chain. Every append is
-* serialized across processes, fsynced before acknowledgement, and idempotent
-* by `eventId`. A malformed, non-canonical, truncated, reordered, or conflicting
-* log fails loudly; the implementation never skips a bad row.
-*
-* The journal machinery itself (hash chain, locking, fsync, idempotent append)
-* is the generic `ledger-core` journal; this module supplies the campaign
-* codec: event schemas, canonical event ordering, and the search state machine.
-*/
-const SEARCH_LEDGER_SCHEMA = "tangle.search-ledger.v1";
-const NON_EMPTY = z.string().min(1).refine((value) => value.trim() === value, "must not contain surrounding whitespace");
-const HASH = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-const LINEAGE_NODE_ID = z.string().regex(/^[a-f0-9]{16}$/);
-const IMMUTABLE_REVISION = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64}|sha256:[a-f0-9]{64}|sha512:[A-Za-z0-9+/=]+)$/);
-const ISO_TIMESTAMP = z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/).refine((value) => Number.isFinite(Date.parse(value)), "invalid timestamp");
-const NON_NEGATIVE_INT = z.number().int().nonnegative().safe();
-const FINITE_NUMBER = z.number().finite();
-const ArtifactRefSchema = z.object({
-	role: NON_EMPTY,
-	uri: NON_EMPTY,
-	sha256: HASH,
-	byteLength: NON_NEGATIVE_INT
-}).strict();
-const SourceRefSchema = z.object({
-	uri: NON_EMPTY,
-	revision: IMMUTABLE_REVISION
-}).strict();
-const FailureReasonSchema = z.object({
-	code: NON_EMPTY,
-	message: NON_EMPTY
-}).strict();
-const EventBaseShape = {
-	eventId: NON_EMPTY,
-	occurredAt: ISO_TIMESTAMP,
-	artifacts: z.array(ArtifactRefSchema).min(1)
-};
-const OperationKindSchema = z.enum([
-	"candidate-generation",
-	"analysis",
-	"selection",
-	"judge",
-	"other"
-]);
-const SearchPlannedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("search-planned"),
-	plan: z.object({
-		candidateSlots: z.array(z.object({
-			slotId: NON_EMPTY,
-			generationOperationId: NON_EMPTY
-		}).strict()).min(1),
-		tasks: z.array(z.object({
-			taskId: NON_EMPTY,
-			source: SourceRefSchema,
-			benchmark: SourceRefSchema,
-			maxAttempts: z.number().int().positive().safe()
-		}).strict()).min(1),
-		operations: z.array(z.object({
-			operationId: NON_EMPTY,
-			kind: OperationKindSchema
-		}).strict()).min(1)
-	}).strict()
-}).strict();
-const CandidateRegisteredSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("candidate-registered"),
-	slotId: NON_EMPTY,
-	generationOperationId: NON_EMPTY,
-	candidateId: NON_EMPTY,
-	lineage: z.object({
-		lineageNodeId: LINEAGE_NODE_ID,
-		parentCandidateIds: z.array(NON_EMPTY),
-		generation: NON_NEGATIVE_INT,
-		proposer: NON_EMPTY,
-		proposerSource: SourceRefSchema
-	}).strict(),
-	surfaces: z.array(z.object({
-		surfaceId: NON_EMPTY,
-		kind: z.enum([
-			"prompt",
-			"tool-contract",
-			"runtime-config",
-			"memory",
-			"knowledge",
-			"agent-profile",
-			"code",
-			"deployment"
-		]),
-		artifact: ArtifactRefSchema
-	}).strict()).min(1)
-}).strict();
-const CandidateSlotClosedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("candidate-slot-closed"),
-	slotId: NON_EMPTY,
-	generationOperationId: NON_EMPTY,
-	reason: FailureReasonSchema
-}).strict();
-const KnownTokensSchema = z.object({
-	status: z.literal("known"),
-	inputTokens: NON_NEGATIVE_INT,
-	outputTokens: NON_NEGATIVE_INT,
-	cachedTokens: NON_NEGATIVE_INT
-}).strict();
-const UnknownSchema = z.object({
-	status: z.literal("unknown"),
-	reason: NON_EMPTY
-}).strict();
-const KnownCostSchema = z.object({
-	status: z.literal("known"),
-	usd: z.number().finite().nonnegative(),
-	source: z.enum([
-		"provider",
-		"pricing-table",
-		"free"
-	])
-}).strict().superRefine((cost, ctx) => {
-	if (cost.source === "free" && cost.usd !== 0) ctx.addIssue({
-		code: "custom",
-		message: "free cost source must have usd 0"
-	});
-});
-const UnknownCostSchema = z.object({
-	status: z.literal("unknown"),
-	knownLowerBoundUsd: z.number().finite().nonnegative(),
-	reason: NON_EMPTY
-}).strict();
-const AccountingSchema = z.object({
-	tokens: z.discriminatedUnion("status", [KnownTokensSchema, UnknownSchema]),
-	cost: z.discriminatedUnion("status", [KnownCostSchema, UnknownCostSchema])
-}).strict();
-const MetricsSchema = z.record(NON_EMPTY, FINITE_NUMBER).superRefine((metrics, ctx) => {
-	for (const key of Object.keys(metrics)) if (key === "__proto__" || key === "constructor" || key === "prototype") ctx.addIssue({
-		code: "custom",
-		message: `unsafe metric key ${key}`
-	});
-});
-const OutcomeSchema = z.discriminatedUnion("status", [
-	z.object({
-		status: z.literal("passed"),
-		score: FINITE_NUMBER,
-		metrics: MetricsSchema
-	}).strict(),
-	z.object({
-		status: z.literal("failed"),
-		score: FINITE_NUMBER,
-		metrics: MetricsSchema,
-		failure: FailureReasonSchema
-	}).strict(),
-	z.object({
-		status: z.literal("errored"),
-		metrics: MetricsSchema,
-		error: FailureReasonSchema.extend({ retryable: z.boolean() }).strict()
-	}).strict()
-]);
-const EffectSchema = z.discriminatedUnion("status", [z.object({
-	status: z.literal("measured"),
-	metric: NON_EMPTY,
-	baselineValue: FINITE_NUMBER,
-	candidateValue: FINITE_NUMBER,
-	delta: FINITE_NUMBER
-}).strict().superRefine((effect, ctx) => {
-	const expected = effect.candidateValue - effect.baselineValue;
-	const tolerance = Number.EPSILON * Math.max(1, Math.abs(expected), Math.abs(effect.delta)) * 8;
-	if (Math.abs(effect.delta - expected) > tolerance) ctx.addIssue({
-		code: "custom",
-		message: "delta must equal candidateValue - baselineValue"
-	});
-}), z.object({
-	status: z.literal("not-measured"),
-	reason: NON_EMPTY
-}).strict()]);
-const SurfaceEvidenceSchema = z.object({
-	surfaceId: NON_EMPTY,
-	fired: z.boolean(),
-	firingCount: NON_NEGATIVE_INT,
-	effect: EffectSchema,
-	evidence: z.array(ArtifactRefSchema).min(1)
-}).strict().superRefine((evidence, ctx) => {
-	if (evidence.fired && evidence.firingCount === 0) ctx.addIssue({
-		code: "custom",
-		message: "a fired surface must have firingCount >= 1"
-	});
-	if (!evidence.fired && evidence.firingCount !== 0) ctx.addIssue({
-		code: "custom",
-		message: "a surface that did not fire must have firingCount 0"
-	});
-	if (!evidence.fired && evidence.effect.status === "measured" && evidence.effect.delta !== 0) ctx.addIssue({
-		code: "custom",
-		message: "a surface that did not fire cannot claim non-zero effect"
-	});
-});
-const TaskAttemptedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("task-attempted"),
-	candidateId: NON_EMPTY,
-	runId: NON_EMPTY,
-	attemptIndex: NON_NEGATIVE_INT,
-	task: z.object({
-		taskId: NON_EMPTY,
-		source: SourceRefSchema
-	}).strict(),
-	identity: z.object({
-		model: z.object({
-			provider: NON_EMPTY,
-			snapshot: NON_EMPTY.refine(modelHasSnapshot, "model must include an immutable snapshot")
-		}).strict(),
-		agent: SourceRefSchema,
-		benchmark: SourceRefSchema
-	}).strict(),
-	outcome: OutcomeSchema,
-	accounting: AccountingSchema,
-	surfaceEvidence: z.array(SurfaceEvidenceSchema).min(1)
-}).strict();
-const SearchOperationRecordedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("search-operation-recorded"),
-	operationId: NON_EMPTY,
-	operationKind: OperationKindSchema,
-	execution: z.discriminatedUnion("kind", [z.object({
-		kind: z.literal("model"),
-		model: z.object({
-			provider: NON_EMPTY,
-			snapshot: NON_EMPTY.refine(modelHasSnapshot, "model must include an immutable snapshot")
-		}).strict(),
-		source: SourceRefSchema
-	}).strict(), z.object({
-		kind: z.literal("deterministic"),
-		source: SourceRefSchema
-	}).strict()]),
-	outcome: z.discriminatedUnion("status", [
-		z.object({ status: z.literal("completed") }).strict(),
-		z.object({
-			status: z.literal("partial"),
-			failure: FailureReasonSchema
-		}).strict(),
-		z.object({
-			status: z.literal("failed"),
-			failure: FailureReasonSchema
-		}).strict()
-	]),
-	accounting: AccountingSchema
-}).strict();
-const CandidateDecidedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("candidate-decided"),
-	candidateId: NON_EMPTY,
-	decision: z.discriminatedUnion("status", [z.object({ status: z.literal("selected") }).strict(), z.object({
-		status: z.literal("rejected"),
-		reason: FailureReasonSchema
-	}).strict()])
-}).strict();
-const SearchCompletedSchema = z.object({
-	...EventBaseShape,
-	kind: z.literal("search-completed"),
-	result: z.discriminatedUnion("status", [z.object({
-		status: z.literal("selected"),
-		candidateId: NON_EMPTY
-	}).strict(), z.object({
-		status: z.literal("all-rejected"),
-		reason: FailureReasonSchema
-	}).strict()])
-}).strict();
-const EventSchema = z.discriminatedUnion("kind", [
-	SearchPlannedSchema,
-	CandidateRegisteredSchema,
-	CandidateSlotClosedSchema,
-	TaskAttemptedSchema,
-	SearchOperationRecordedSchema,
-	CandidateDecidedSchema,
-	SearchCompletedSchema
-]);
-const EntrySchema = z.object({
-	schema: z.literal(SEARCH_LEDGER_SCHEMA),
-	campaignId: NON_EMPTY,
-	sequence: NON_NEGATIVE_INT,
-	previousHash: z.union([HASH, z.null()]),
-	event: EventSchema,
-	entryHash: HASH
-}).strict();
-/** Validate and return a canonical copy. Arrays whose order is not semantic are
-* sorted so retries from different processes produce byte-identical events. */
-function validateSearchLedgerEvent(input) {
-	const parsed = EventSchema.safeParse(input);
-	if (!parsed.success) throw new SearchLedgerError(`invalid search ledger event: ${formatZodError(parsed.error)}`);
-	return normalizeEvent(parsed.data);
-}
-/** Open a durable filesystem search ledger. Construction performs no I/O; the
-* first `append` or `replay` validates the complete existing file. */
-function openSearchLedger(options) {
-	if (options.path.trim().length === 0) throw new SearchLedgerError("ledger path is empty");
-	return new FileSearchLedger(options.path, options.campaignId, options.trustedHead);
-}
-function searchLedgerCodec(campaignId) {
-	return {
-		...SEARCH_LEDGER_FILE_CONTEXT,
-		header: {
-			schema: SEARCH_LEDGER_SCHEMA,
-			campaignId
-		},
-		conflictError: (message) => new SearchLedgerConflictError(message),
-		parseEntry: parseSearchLedgerEntry,
-		checkEntryHeader: (entry, index) => {
-			if (entry.campaignId !== campaignId) throw new SearchLedgerIntegrityError(`entry ${index} belongs to campaign ${entry.campaignId}, expected ${campaignId}`);
-		},
-		createProjector: () => createSearchLedgerProjector(campaignId)
-	};
-}
-/** Append-only file-backed search ledger with idempotent writes and replay. */
-var FileSearchLedger = class {
-	path;
-	campaignId;
-	trustedHeadPath;
-	trustedHeadMode;
-	journal;
-	constructor(path, campaignId, trustedHead = "pin") {
-		if (path.trim().length === 0) throw new SearchLedgerError("ledger path is empty");
-		if (campaignId.length === 0) throw new SearchLedgerError("campaignId is empty");
-		if (campaignId.trim() !== campaignId) throw new SearchLedgerError("campaignId must not contain surrounding whitespace");
-		this.campaignId = campaignId;
-		this.trustedHeadMode = trustedHead;
-		this.journal = new FileLedgerJournal(path, searchLedgerCodec(campaignId), { requireTrustedHead: trustedHead === "require" });
-		this.path = this.journal.path;
-		this.trustedHeadPath = this.journal.trustedHeadPath;
-	}
-	async replay() {
-		return (await this.journal.replay()).projection;
-	}
-	async append(input) {
-		const event = validateSearchLedgerEvent(input);
-		const { entry, appended, projection } = await this.journal.append(event, { pinHead: this.trustedHeadMode !== "off" });
-		return {
-			entry,
-			appended,
-			replay: projection
-		};
-	}
-	async trustedHead() {
-		return this.journal.trustedHead();
-	}
-	async pinTrustedHead() {
-		return this.journal.pinTrustedHead();
-	}
-	async clearTrustedHead() {
-		return this.journal.clearTrustedHead();
-	}
-};
-function parseSearchLedgerEntry(raw, context) {
-	const parsed = EntrySchema.safeParse(raw);
-	if (!parsed.success) throw new SearchLedgerIntegrityError(`search ledger ${context.path} has a malformed entry at line ${context.line}: ${formatZodError(parsed.error)}`);
-	const entry = parsed.data;
-	if (canonicalString(validateSearchLedgerEvent(entry.event)) !== canonicalString(entry.event)) throw new SearchLedgerIntegrityError(`search ledger ${context.path} has non-canonical event ordering at line ${context.line}`);
-	return entry;
-}
-/** Replay the campaign search state machine over chain-verified entries. The
-* generic journal owns sequence, hash, and eventId-uniqueness checks; this
-* projector owns every campaign invariant and builds the replay projection. */
-function createSearchLedgerProjector(campaignId) {
-	const candidates = /* @__PURE__ */ new Map();
-	const candidateBySlot = /* @__PURE__ */ new Map();
-	const closedSlots = /* @__PURE__ */ new Map();
-	const lineageNodes = /* @__PURE__ */ new Map();
-	const runIds = /* @__PURE__ */ new Set();
-	const attemptKeys = /* @__PURE__ */ new Set();
-	const candidateEvents = [];
-	const closedSlotEvents = [];
-	const attempts = [];
-	const operationEvents = [];
-	const operationsById = /* @__PURE__ */ new Map();
-	const decisions = [];
-	let planEvent = null;
-	let completion = null;
-	let previousOccurredAt = Number.NEGATIVE_INFINITY;
-	const apply = (entry, index) => {
-		const event = entry.event;
-		if (completion) throw new SearchLedgerIntegrityError(`event ${event.eventId} appears after terminal event ${completion.eventId}`);
-		const occurredAt = Date.parse(event.occurredAt);
-		if (occurredAt < previousOccurredAt) throw new SearchLedgerIntegrityError(`event ${event.eventId} occurred before the preceding durable event`);
-		previousOccurredAt = occurredAt;
-		assertUnique(event.artifacts.map(artifactKey), "artifact receipt", event.eventId);
-		if (event.kind === "search-planned") {
-			if (index !== 0 || planEvent) throw new SearchLedgerIntegrityError("search plan must be the first and only plan event");
-			assertUnique(event.plan.candidateSlots.map((slot) => slot.slotId), "candidate slot", event.eventId);
-			assertUnique(event.plan.tasks.map((task) => task.taskId), "planned taskId", event.eventId);
-			assertUnique(event.plan.operations.map((operation) => operation.operationId), "planned operationId", event.eventId);
-			for (const slot of event.plan.candidateSlots) if (event.plan.operations.find((operation) => operation.operationId === slot.generationOperationId)?.kind !== "candidate-generation") throw new SearchLedgerIntegrityError(`candidate slot ${slot.slotId} references unplanned candidate-generation operation ${slot.generationOperationId}`);
-			planEvent = event;
-			return;
-		}
-		if (!planEvent) throw new SearchLedgerIntegrityError(`event ${event.eventId} appears before the required search plan`);
-		if (event.kind === "candidate-registered") {
-			if (candidates.has(event.candidateId)) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} was registered twice`);
-			const plannedSlot = planEvent.plan.candidateSlots.find((slot) => slot.slotId === event.slotId);
-			if (!plannedSlot) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} binds unknown slot ${event.slotId}`);
-			if (candidateBySlot.has(event.slotId)) throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} was bound twice`);
-			if (closedSlots.has(event.slotId)) throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} was already closed`);
-			if (event.generationOperationId !== plannedSlot.generationOperationId) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} generation operation ${event.generationOperationId} does not match slot ${event.slotId} plan ${plannedSlot.generationOperationId}`);
-			const generationOperation = operationsById.get(event.generationOperationId);
-			if (!generationOperation) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} precedes generation operation ${event.generationOperationId}`);
-			if (generationOperation.outcome.status === "failed") throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} cannot bind failed generation operation ${event.generationOperationId}`);
-			const previousCandidate = lineageNodes.get(event.lineage.lineageNodeId);
-			if (previousCandidate) throw new SearchLedgerIntegrityError(`lineage node ${event.lineage.lineageNodeId} is already bound to ${previousCandidate}`);
-			assertUnique(event.lineage.parentCandidateIds, "parentCandidateId", event.eventId);
-			const parents = event.lineage.parentCandidateIds.map((id) => {
-				const parent = candidates.get(id);
-				if (!parent) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} references unknown parent ${id}`);
-				return parent;
-			});
-			const expectedGeneration = parents.length === 0 ? 0 : Math.max(...parents.map((parent) => parent.registered.lineage.generation)) + 1;
-			if (event.lineage.generation !== expectedGeneration) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} generation ${event.lineage.generation} does not follow its parents (expected ${expectedGeneration})`);
-			assertUnique(event.surfaces.map((surface) => surface.surfaceId), "surfaceId", event.eventId);
-			candidates.set(event.candidateId, {
-				registered: event,
-				attempts: [],
-				decision: null
-			});
-			candidateBySlot.set(event.slotId, event.candidateId);
-			lineageNodes.set(event.lineage.lineageNodeId, event.candidateId);
-			candidateEvents.push(event);
-			return;
-		}
-		if (event.kind === "task-attempted") {
-			const candidate = candidates.get(event.candidateId);
-			if (!candidate) throw new SearchLedgerIntegrityError(`attempt ${event.eventId} references unknown candidate ${event.candidateId}`);
-			if (candidate.decision) throw new SearchLedgerIntegrityError(`attempt ${event.eventId} appears after candidate ${event.candidateId} was decided`);
-			const plannedTask = planEvent.plan.tasks.find((task) => task.taskId === event.task.taskId);
-			if (!plannedTask) throw new SearchLedgerIntegrityError(`attempt ${event.eventId} references unplanned task ${event.task.taskId}`);
-			if (canonicalString(plannedTask.source) !== canonicalString(event.task.source) || canonicalString(plannedTask.benchmark) !== canonicalString(event.identity.benchmark)) throw new SearchLedgerIntegrityError(`task ${event.task.taskId} does not match its planned source identity`);
-			if (event.attemptIndex >= plannedTask.maxAttempts) throw new SearchLedgerIntegrityError(`task ${event.task.taskId} attempt ${event.attemptIndex} exceeds planned maxAttempts ${plannedTask.maxAttempts}`);
-			if (runIds.has(event.runId)) throw new SearchLedgerIntegrityError(`runId ${event.runId} was recorded twice`);
-			runIds.add(event.runId);
-			const attemptKey = canonicalString([
-				event.candidateId,
-				event.task.taskId,
-				event.attemptIndex
-			]);
-			if (attemptKeys.has(attemptKey)) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} task ${event.task.taskId} attempt ${event.attemptIndex} was recorded twice`);
-			const expectedAttemptIndex = candidate.attempts.filter((attempt) => attempt.task.taskId === event.task.taskId).length;
-			if (event.attemptIndex !== expectedAttemptIndex) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} task ${event.task.taskId} attempt index ${event.attemptIndex} is not contiguous (expected ${expectedAttemptIndex})`);
-			const previousAttempt = candidate.attempts.find((attempt) => attempt.task.taskId === event.task.taskId);
-			if (previousAttempt?.outcome.status !== void 0 && previousAttempt.outcome.status !== "errored") throw new SearchLedgerIntegrityError(`task ${event.task.taskId} was retried after a measured outcome`);
-			if (previousAttempt && canonicalString({
-				task: previousAttempt.task,
-				identity: previousAttempt.identity
-			}) !== canonicalString({
-				task: event.task,
-				identity: event.identity
-			})) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} task ${event.task.taskId} changed immutable execution identity between attempts`);
-			attemptKeys.add(attemptKey);
-			const declared = candidate.registered.surfaces.map((surface) => surface.surfaceId).sort();
-			const observed = event.surfaceEvidence.map((surface) => surface.surfaceId).sort();
-			assertUnique(observed, "surface evidence", event.eventId);
-			for (const evidence of event.surfaceEvidence) assertUnique(evidence.evidence.map(artifactKey), "surface evidence receipt", event.eventId);
-			if (canonicalString(declared) !== canonicalString(observed)) throw new SearchLedgerIntegrityError(`attempt ${event.eventId} surface evidence does not exactly cover candidate ${event.candidateId}`);
-			candidate.attempts.push(event);
-			attempts.push(event);
-			return;
-		}
-		if (event.kind === "search-operation-recorded") {
-			const plannedOperation = planEvent.plan.operations.find((operation) => operation.operationId === event.operationId);
-			if (!plannedOperation) throw new SearchLedgerIntegrityError(`operation ${event.operationId} was not declared in the search plan`);
-			if (plannedOperation.kind !== event.operationKind) throw new SearchLedgerIntegrityError(`operation ${event.operationId} kind ${event.operationKind} does not match planned ${plannedOperation.kind}`);
-			if (operationsById.has(event.operationId)) throw new SearchLedgerIntegrityError(`operation ${event.operationId} was recorded twice`);
-			operationsById.set(event.operationId, event);
-			operationEvents.push(event);
-			return;
-		}
-		if (event.kind === "candidate-slot-closed") {
-			const plannedSlot = planEvent.plan.candidateSlots.find((slot) => slot.slotId === event.slotId);
-			if (!plannedSlot) throw new SearchLedgerIntegrityError(`candidate slot closure ${event.eventId} references unknown slot ${event.slotId}`);
-			if (event.generationOperationId !== plannedSlot.generationOperationId) throw new SearchLedgerIntegrityError(`candidate slot closure ${event.eventId} generation operation ${event.generationOperationId} does not match slot ${event.slotId} plan ${plannedSlot.generationOperationId}`);
-			if (candidateBySlot.has(event.slotId)) throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} was already bound to a candidate`);
-			if (closedSlots.has(event.slotId)) throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} was closed twice`);
-			const operation = operationsById.get(event.generationOperationId);
-			if (!operation) throw new SearchLedgerIntegrityError(`candidate slot closure ${event.eventId} precedes operation ${event.generationOperationId}`);
-			if (operation.outcome.status === "completed") throw new SearchLedgerIntegrityError(`candidate slot ${event.slotId} cannot close from completed operation ${event.generationOperationId}`);
-			closedSlots.set(event.slotId, event);
-			closedSlotEvents.push(event);
-			return;
-		}
-		if (event.kind === "candidate-decided") {
-			const candidate = candidates.get(event.candidateId);
-			if (!candidate) throw new SearchLedgerIntegrityError(`decision ${event.eventId} references unknown candidate ${event.candidateId}`);
-			if (candidate.decision) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} was decided twice`);
-			if (event.decision.status === "selected") {
-				if (!candidate.attempts.some((attempt) => attempt.outcome.status !== "errored")) throw new SearchLedgerIntegrityError(`candidate ${event.candidateId} cannot be selected without a measured task outcome`);
-				if (decisions.some((decision) => decision.decision.status === "selected")) throw new SearchLedgerIntegrityError("more than one candidate was selected");
-			}
-			candidate.decision = event;
-			decisions.push(event);
-			return;
-		}
-		const missingCandidateSlots = planEvent.plan.candidateSlots.filter((slot) => !candidateBySlot.has(slot.slotId) && !closedSlots.has(slot.slotId)).map((slot) => slot.slotId);
-		if (missingCandidateSlots.length > 0) throw new SearchLedgerIntegrityError(`search completed with missing candidate slots: ${missingCandidateSlots.join(", ")}`);
-		const missingTaskOutcomes = plannedTaskOutcomeKeys(planEvent, candidates);
-		if (missingTaskOutcomes.length > 0) throw new SearchLedgerIntegrityError(`search completed with missing task outcomes: ${missingTaskOutcomes.join(", ")}`);
-		const missingOperations = planEvent.plan.operations.filter((operation) => !operationsById.has(operation.operationId)).map((operation) => operation.operationId);
-		if (missingOperations.length > 0) throw new SearchLedgerIntegrityError(`search completed with missing search operations: ${missingOperations.join(", ")}`);
-		for (const operation of planEvent.plan.operations) {
-			if (operation.kind !== "candidate-generation") continue;
-			const generationOutcome = operationsById.get(operation.operationId).outcome.status;
-			const slots = planEvent.plan.candidateSlots.filter((slot) => slot.generationOperationId === operation.operationId);
-			if (slots.length === 0) continue;
-			const registeredCount = slots.filter((slot) => candidateBySlot.has(slot.slotId)).length;
-			const closedCount = slots.filter((slot) => closedSlots.has(slot.slotId)).length;
-			if (generationOutcome === "completed" && closedCount > 0) throw new SearchLedgerIntegrityError(`completed generation operation ${operation.operationId} contains ${closedCount} closed slot(s)`);
-			if (generationOutcome === "failed" && registeredCount > 0) throw new SearchLedgerIntegrityError(`failed generation operation ${operation.operationId} contains ${registeredCount} registered candidate(s)`);
-			if (generationOutcome === "partial" && (registeredCount === 0 || closedCount === 0)) throw new SearchLedgerIntegrityError(`partial generation operation ${operation.operationId} must contain both a registered candidate and a closed slot`);
-		}
-		const pending = [...candidates.values()].filter((candidate) => candidate.decision === null);
-		if (pending.length > 0) throw new SearchLedgerIntegrityError(`search completed with ${pending.length} candidate decision(s) missing`);
-		const selected = decisions.filter((decision) => decision.decision.status === "selected");
-		if (event.result.status === "selected") {
-			if (selected.length !== 1 || selected[0].candidateId !== event.result.candidateId) throw new SearchLedgerIntegrityError(`search completion winner ${event.result.candidateId} does not match candidate decisions`);
-		} else if (selected.length !== 0) throw new SearchLedgerIntegrityError("all-rejected completion contains a selected candidate");
-		completion = event;
-	};
-	const finish = (entries) => {
-		const selectedDecisions = decisions.filter((decision) => decision.decision.status === "selected");
-		const rejectedDecisions = decisions.filter((decision) => decision.decision.status === "rejected");
-		const outcomeCounts = {
-			passed: 0,
-			failed: 0,
-			errored: 0
-		};
-		const operationOutcomeCounts = {
-			completed: 0,
-			partial: 0,
-			failed: 0
-		};
-		let inputTokens = 0;
-		let outputTokens = 0;
-		let cachedTokens = 0;
-		let costUsd = 0;
-		const unknownTokenEventIds = [];
-		const unknownCostEventIds = [];
-		for (const attempt of attempts) outcomeCounts[attempt.outcome.status] += 1;
-		for (const operation of operationEvents) operationOutcomeCounts[operation.outcome.status] += 1;
-		for (const costedEvent of [...attempts, ...operationEvents]) {
-			if (costedEvent.accounting.tokens.status === "known") {
-				inputTokens += costedEvent.accounting.tokens.inputTokens;
-				outputTokens += costedEvent.accounting.tokens.outputTokens;
-				cachedTokens += costedEvent.accounting.tokens.cachedTokens;
-			} else unknownTokenEventIds.push(costedEvent.eventId);
-			if (costedEvent.accounting.cost.status === "known") costUsd += costedEvent.accounting.cost.usd;
-			else {
-				costUsd += costedEvent.accounting.cost.knownLowerBoundUsd;
-				unknownCostEventIds.push(costedEvent.eventId);
-			}
-		}
-		const accounting = unknownTokenEventIds.length === 0 && unknownCostEventIds.length === 0 ? {
-			status: "known",
-			inputTokens,
-			outputTokens,
-			cachedTokens,
-			costUsd
-		} : {
-			status: "partial",
-			knownInputTokens: inputTokens,
-			knownOutputTokens: outputTokens,
-			knownCachedTokens: cachedTokens,
-			knownCostUsd: costUsd,
-			unknownTokenEventIds,
-			unknownCostEventIds
-		};
-		const selectedCandidateId = completion?.result.status === "selected" ? completion.result.candidateId : null;
-		const status = completion?.result.status === "selected" ? "selected" : completion?.result.status === "all-rejected" ? "all-rejected" : "in-progress";
-		const missingCandidateSlots = planEvent?.plan.candidateSlots.filter((slot) => !candidateBySlot.has(slot.slotId) && !closedSlots.has(slot.slotId)).map((slot) => slot.slotId) ?? [];
-		const missingTaskOutcomes = planEvent ? plannedTaskOutcomeKeys(planEvent, candidates) : [];
-		const missingOperations = planEvent?.plan.operations.filter((operation) => !operationsById.has(operation.operationId)).map((operation) => operation.operationId) ?? [];
-		return {
-			entries: [...entries],
-			plan: planEvent,
-			candidates: candidateEvents,
-			closedCandidateSlots: closedSlotEvents,
-			attempts,
-			operations: operationEvents,
-			decisions,
-			completion,
-			audit: {
-				campaignId,
-				eventCount: entries.length,
-				candidateCount: candidates.size,
-				closedCandidateSlotCount: closedSlots.size,
-				attemptCount: attempts.length,
-				operationCount: operationEvents.length,
-				outcomes: outcomeCounts,
-				operationOutcomes: operationOutcomeCounts,
-				decisions: {
-					selected: selectedDecisions.length,
-					rejected: rejectedDecisions.length,
-					pending: candidates.size - decisions.length
-				},
-				expected: {
-					candidateSlots: planEvent?.plan.candidateSlots.length ?? 0,
-					taskOutcomes: candidates.size * (planEvent?.plan.tasks.length ?? 0),
-					operations: planEvent?.plan.operations.length ?? 0,
-					missingCandidateSlots,
-					missingTaskOutcomes,
-					missingOperations
-				},
-				status,
-				selectedCandidateId,
-				accounting,
-				headHash: entries.at(-1)?.entryHash ?? null
-			}
-		};
-	};
-	return {
-		apply,
-		finish
-	};
-}
-function plannedTaskOutcomeKeys(planEvent, candidates) {
-	const missing = [];
-	const registeredCandidates = [...candidates.values()].sort((a, b) => compareStrings(a.registered.slotId, b.registered.slotId));
-	for (const candidate of registeredCandidates) {
-		const slotId = candidate.registered.slotId;
-		for (const task of planEvent.plan.tasks) if (!candidate.attempts.some((attempt) => attempt.task.taskId === task.taskId && attempt.outcome.status !== "errored")) missing.push(`${slotId}/${task.taskId}`);
-	}
-	return missing;
-}
-function normalizeEvent(event) {
-	const artifacts = sortArtifacts(event.artifacts);
-	if (event.kind === "search-planned") return {
-		...event,
-		artifacts,
-		plan: {
-			candidateSlots: [...event.plan.candidateSlots].sort((a, b) => compareStrings(a.slotId, b.slotId)),
-			tasks: [...event.plan.tasks].sort((a, b) => compareStrings(a.taskId, b.taskId)),
-			operations: [...event.plan.operations].sort((a, b) => compareStrings(a.operationId, b.operationId))
-		}
-	};
-	if (event.kind === "candidate-registered") return {
-		...event,
-		artifacts,
-		lineage: {
-			...event.lineage,
-			parentCandidateIds: sortedStrings(event.lineage.parentCandidateIds)
-		},
-		surfaces: [...event.surfaces].map((surface) => ({
-			...surface,
-			artifact: { ...surface.artifact }
-		})).sort((a, b) => compareStrings(a.surfaceId, b.surfaceId))
-	};
-	if (event.kind === "task-attempted") return {
-		...event,
-		artifacts,
-		surfaceEvidence: [...event.surfaceEvidence].map((evidence) => ({
-			...evidence,
-			evidence: sortArtifacts(evidence.evidence)
-		})).sort((a, b) => compareStrings(a.surfaceId, b.surfaceId))
-	};
-	return {
-		...event,
-		artifacts
-	};
-}
-function sortArtifacts(artifacts) {
-	return [...artifacts].map((artifact) => ({ ...artifact })).sort((a, b) => compareStrings(artifactKey(a), artifactKey(b)));
-}
-function artifactKey(artifact) {
-	return canonicalString(artifact);
-}
-function compareStrings(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0;
-}
-function sortedStrings(values) {
-	return [...values].sort();
-}
-function assertUnique(values, label, eventId) {
-	if (new Set(values).size !== values.length) throw new SearchLedgerIntegrityError(`event ${eventId} contains duplicate ${label} values`);
-}
-function formatZodError(error) {
-	return error.issues.map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`).join("; ");
-}
-//#endregion
-//#region src/campaign/transient-failure.ts
-const BASE_TRANSIENT = /\b50[234]\b|no stream output|produced no stream|admission timed out|admission_rejected|queue_timeout|fetch failed|ECONNRESET|This operation was aborted/i;
-const TIMEOUT_PATTERN = /timeout after \d+ ?ms|cli-bridge timeout/i;
-/**
-* True when the error text describes an infrastructure hiccup that should be
-* retried rather than scored. Empty/undefined input is not transient.
-*/
-function isTransientTransportFailure(message, opts = {}) {
-	if (!message) return false;
-	if (BASE_TRANSIENT.test(message)) return true;
-	if ((opts.retryFullDurationTimeouts ?? false) && TIMEOUT_PATTERN.test(message)) return true;
-	for (const p of opts.extraPatterns ?? []) if (p.test(message)) return true;
-	return false;
-}
-//#endregion
 //#region src/campaign/upstream-evaluators.ts
 function phoenixEvaluatorJudge(evaluator, options) {
 	if ((evaluator.optimizationDirection === "MINIMIZE" || evaluator.optimizationDirection === "NEUTRAL") && !options.toComposite) throw new TypeError(`phoenixEvaluatorJudge requires toComposite for a ${evaluator.optimizationDirection} evaluator`);
@@ -3765,6 +3047,6 @@ function resolveWorktreePath(surface, worktreeDir) {
 	return verifyCodeSurface(surface, worktreeDir).path;
 }
 //#endregion
-export { rolloutArgumentDiff as A, scoreboardSummary as C, FsLabeledScenarioStore as D, neutralizeText as E, planEvalFixtureRun as F, analyzeCrossSurfaceInteractions as I, buildTraceAnalystSurfaceDispatch as L, discoverEvalFixtures as M, loadEvalFixture as N, LabeledScenarioStoreError as O, loadEvalFixtureScenarios as P, traceAnalystQualityJudge as R, scoreUserStory as S, createOpenAiCompatibleExecutionOwner 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, neutralizationGate as j, classifyUngroundedLiterals 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 };
+export { analyzeCrossSurfaceInteractions as A, classifyUngroundedLiterals as C, loadEvalFixture as D, discoverEvalFixtures as E, traceAnalystQualityJudge as M, loadEvalFixtureScenarios as O, LabeledScenarioStoreError as S, neutralizationGate as T, scoreboardSummary as _, autoevalsScorerJudge as a, neutralizeText as b, selectDiscriminative as c, runProfileMatrixSegment as d, ProfileMatrixError as f, scoreUserStory as g, renderScoreboardMarkdown as h, verifyCodeSurface as i, buildTraceAnalystSurfaceDispatch as j, planEvalFixtureRun as k, createProfileMatrixPlan as l, makePlaybackDispatch as m, gitWorktreeAdapter as n, phoenixEvaluatorJudge as o, runProfileMatrix as p, resolveWorktreePath as r, scoreDiscrimination as s, WorktreeAdapterError as t, finalizeProfileMatrix as u, userStoryScoreboard as v, rolloutArgumentDiff as w, FsLabeledScenarioStore as x, crowdedFrontierParent as y };
 
-//# sourceMappingURL=campaign-CN_7xJdV.js.map
+//# sourceMappingURL=campaign-BSmOwskD.js.map