@tangle-network/agent-eval 0.217.1 → 0.218.1

package/dist/{benchmark-command-xQK8nOI6.js → benchmark-command-BupdHRyf.js}

@@ -3,18 +3,18 @@ import { a as hashCanonical, i as compareCodeUnits, o as jsonDocument, r as cano
 import { i as pairedBootstrap, t as mean$3 } from "./mean-BbA_JCzW.js";
 import { a as resolveModelPricing } from "./metrics-BKaPBtIG.js";
 import { a as CostLedgerPersistenceError, i as CostCeilingReachedError, n as CostAccountingIncompleteError, o as CostReceiptCaptureError, r as CostCallConflictError, s as CostReservationExceededError, t as CostLedger } from "./cost-ledger-D0352Z4d.js";
-import { l as withLedgerFileLock, u as writeLedgerFileAtomically } from "./journal-CR4QikYp.js";
-import "./ledger-core-DrJhbms9.js";
-import { M as fsCampaignStorage, b as AnalystFindingSchema, i as startExternalOptimizerModelProxy, j as createRunCostLedger, r as runWithCleanup, v as resolveExternalOptimizerProcessLimits } from "./external-optimizer-subprocess-XIHBOSKt.js";
+import { l as withLedgerFileLock, u as writeLedgerFileAtomically } from "./journal-C7om8Gum.js";
+import "./ledger-core-CAxUdDk0.js";
+import { M as fsCampaignStorage, b as AnalystFindingSchema, i as startExternalOptimizerModelProxy, j as createRunCostLedger, r as runWithCleanup, v as resolveExternalOptimizerProcessLimits } from "./external-optimizer-subprocess-B5gdLRZv.js";
 import { s as redactText } from "./redact-mtkTiJVk.js";
 import { i as makeFinding } from "./types-DqFMNTgK.js";
-import { t as acquireSingleRunLock } from "./single-run-lock-U58yf8N6.js";
+import { t as acquireSingleRunLock } from "./single-run-lock-Dekd8_Wv.js";
 import { a as LlmCallError, n as isRecord, o as LlmResponseError } from "./json-BhdsJaOQ.js";
 import { A as RawAnalystFindingSchema, U as assertValidAnalystUsageReceipt, W as usageReceiptFromCostLedger, j as evidenceRefsFromRawFinding, k as RAW_FINDING_SCHEMA_PROMPT, m as TRACE_ANALYSIS_LIMITS, n as runTraceAnalyst } from "./kind-factory-Gy4fXixd.js";
-import { n as callLlmJson } from "./llm-client-BshCREn6.js";
-import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-DhdCr1Dc.js";
+import { n as callLlmJson } from "./llm-client-_Y6ic-tf.js";
+import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-CSMwudLO.js";
 import { i as otlpTextToTraceAnalysisStore, n as DEFAULT_MAX_TRACE_FILE_BYTES, t as BufferTraceStore } from "./store-otlp-BteDAbHK.js";
-import "./external-optimizer-process-KVFGvYX1.js";
+import "./external-optimizer-process-C3Wm7Vhn.js";
 import { t as assertEqualDeclarativeTerms } from "./equal-terms-DbPGcVtI.js";
 import { c as runPrimeExchange, l as decodeReplyRows, n as buildPrimePrompt, o as primeProtocolSha256, s as projectPrimeTrajectory, t as analystUsageReceiptFromPrimeUsage } from "./prime-protocol-BFgGrEMP.js";
 import { t as nodeHttpPrimeBridgeTransport } from "./prime-bridge-transport-Z3cpKGoV.js";
@@ -1877,7 +1877,7 @@ Object.freeze([
 	"package.json",
 	"pnpm-lock.yaml"
 ]);
-const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "1340bdb155f062be26028c367d5f65dcd470c3417bdf0ab615fa0fab121f3d72";
+const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "79b7d34288f4a5c3fd39cc1d875b98507d822a27ae5adf2ad299c7ba2935fca4";
 const ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 = "1e03f2daed356d60316aabefb407ec1e437ac94d408d61eea4ae096e9c6fbb5b";
 const ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 = "4dba263b6256a30d56c7fdb2d992d3a953c0035d731f359b704db806f68f75ac";
 const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
@@ -1905,6 +1905,7 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/analyst/benchmark-instructions-override.ts",
 	"src/analyst/benchmark-public-adapters.ts",
 	"src/analyst/benchmark-public-calibration.ts",
+	"src/analyst/benchmark-public-chunked.ts",
 	"src/analyst/benchmark-public-consensus.ts",
 	"src/analyst/benchmark-public-data.ts",
 	"src/analyst/benchmark-public-errors.ts",
@@ -1974,6 +1975,7 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/ledger-core/index.ts",
 	"src/ledger-core/journal-file.ts",
 	"src/ledger-core/journal.ts",
+	"src/ledger-core/lock-holder.ts",
 	"src/ledger-core/merkle.ts",
 	"src/ledger-core/projector-snapshot.ts",
 	"src/ledger-core/trusted-head.ts",
@@ -2027,7 +2029,7 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/trace/redaction/detectors.ts",
 	"src/verdict-cache.ts"
 ]);
-const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "705fdcf5f1226d15fde853ffe5c8f8771fea0dfb0f3e66671748cff8aa70e8b5";
+const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "f3ef71f1819dc0f9b35907c01bd2218e2802931b8749b77749127c3054149f3e";
 //#endregion
 //#region src/analyst/benchmark-evidence-validation.ts
 const MIN_ACTION_EXCERPT_CHARACTERS = 12;
@@ -4170,89 +4172,10 @@ function analystDefinitionAsymmetries(definitions) {
 	};
 }
 //#endregion
-//#region src/analyst/benchmark-public-model.ts
-/** The direct arm as a declarative unit for one public dataset. */
-function publicDirectAnalystDefinition(dataset, args) {
-	const actor = dataset === "agentrx" ? "agentrx-root-cause-localizer" : "codetracebench-step-localizer";
-	const outputAdapter = dataset === "agentrx" ? "agentrx-taxonomy-and-root-step" : "codetracebench-incorrect-block";
-	return {
-		id: "direct",
-		description: "One-shot JSON baseline over the caller-owned model path.",
-		version: "1.0.0",
-		area: dataset === "agentrx" ? "root-cause" : "incorrect",
-		profile: { model: { reasoningEffort: "none" } },
-		question: "",
-		taskDefinition: publicBenchmarkTaskPrompt(dataset),
-		projection: {
-			mode: "chunked",
-			attributeByteCaps: TRACE_PROJECTION_ATTRIBUTE_BYTE_CAPS
-		},
-		replyContract: directReplyContract(dataset),
-		contractLimits: dataset === "agentrx" ? { maxFindings: 1 } : {
-			maxBlocks: 16,
-			maxBlockSteps: 12
-		},
-		budget: {
-			timeoutMs: args.timeoutMs,
-			maxCostUsd: args.maxCostUsd,
-			maxOutputTokens: args.maxOutputTokens
-		},
-		repair: { turns: 0 },
-		protocolSha256: publicBenchmarkProtocolSha256(dataset),
-		binding: {
-			kind: "chunked",
-			subjectFromCaseId: (caseId) => trajectoryIdFromCaseId$2(dataset, caseId),
-			baseMetadata: {
-				analysisMode: "direct-baseline",
-				outputAdapter
-			},
-			costActor: actor,
-			costPhase: "analyst.public-benchmark",
-			userMessage: (rendered) => `TRACE DATA:\n${rendered}\n\nReturn the analysis JSON object.`,
-			async expandRows({ subject, rows, store, analystId, producedAt, providerModel, signal }) {
-				const converted = await publicBenchmarkPredictionsToFindings({
-					dataset,
-					trajectoryId: subject,
-					predictions: rows,
-					store,
-					analystId,
-					providerModel: requiredString(providerModel ?? "", "finding providerModel"),
-					producedAt: requiredString(producedAt ?? "", "finding producedAt"),
-					...signal ? { signal } : {}
-				});
-				return {
-					findings: converted.findings,
-					diagnostics: converted.diagnostics
-				};
-			},
-			...dataset === "codetracebench" ? { verifyFindings: async (args) => {
-				await validateCodeTraceFindingEvidence({
-					trajectoryId: args.subject,
-					findings: [...args.findings],
-					store: args.store,
-					...args.signal ? { signal: args.signal } : {}
-				});
-			} } : {}
-		}
-	};
-}
-/** Thin shell: validate config, declare the definition, run the chunked strategy. */
-function createPublicBenchmarkDirectRunner(dataset, config) {
-	if (config.instructionsOverride) throw new Error("the direct runner executes only the stock protocol; an instructions override requires the dspy-rlm runner");
-	const maxOutputTokens = positiveSafeInteger(config.maxOutputTokens, "maxOutputTokens");
-	return runChunkedAnalystDefinition(publicDirectAnalystDefinition(dataset, {
-		timeoutMs: positiveSafeInteger(config.timeoutMs, "timeoutMs"),
-		maxOutputTokens,
-		maxCostUsd: config.maxCostUsdPerAnalysis ?? 1
-	}), config);
-}
-/**
-* Compile a chunked-projection definition into a runnable one-shot JSON arm
-* over the caller-owned model path. Prompt content, the projection ladder,
-* the reply grammar, and the budget declaration come from the definition;
-* caching, cost settlement, and the model proxy are transport machinery.
-*/
-function runChunkedAnalystDefinition(definition, config) {
+//#region src/analyst/benchmark-public-chunked.ts
+/** The chunked one-shot JSON strategy: compile a chunked definition into a runnable arm. */
+/** Refuse a definition the one-shot JSON strategy cannot execute exactly as declared. */
+function checkChunkedDefinition(definition, config) {
 	const { projection, binding, replyContract } = definition;
 	if (projection.mode !== "chunked" || binding.kind !== "chunked") throw new AnalystExpressivenessError(`the chunked one-shot strategy compiles only chunked projections; definition '${definition.id}' declares projection '${projection.mode}' with a '${binding.kind}' binding`);
 	if (config.instructionsOverride) throw new Error("the direct runner executes only the stock protocol; an instructions override requires the dspy-rlm runner");
@@ -4261,6 +4184,16 @@ function runChunkedAnalystDefinition(definition, config) {
 	if (reasoningEffort !== "none") throw new AnalystExpressivenessError(`the one-shot JSON strategy runs with thinking disabled and can express only reasoning effort 'none'; definition '${definition.id}' declares '${reasoningEffort}'`);
 	if (!replyContract.parseEnvelope) throw new AnalystExpressivenessError(`the one-shot JSON strategy needs a strict reply envelope; definition '${definition.id}' declares no parseEnvelope`);
 	if (definition.taskDefinition === void 0) throw new AnalystExpressivenessError(`the one-shot JSON strategy composes its system prompt from the task definition; definition '${definition.id}' declares none`);
+	return {
+		binding,
+		replyContract,
+		attributeByteCaps: projection.attributeByteCaps,
+		taskDefinition: definition.taskDefinition
+	};
+}
+/** Validate the definition and transport, then resolve the model, budget, ledger and system prompt. */
+function compileChunkedArm(definition, config) {
+	const { binding, replyContract, attributeByteCaps, taskDefinition } = checkChunkedDefinition(definition, config);
 	const model = requiredString(config.model, "model");
 	const callRef = requiredString(config.callRef, "callRef");
 	if (typeof config.call !== "function") throw new TypeError("call must be a function");
@@ -4273,243 +4206,296 @@ function runChunkedAnalystDefinition(definition, config) {
 		maxOutputTokens,
 		maxCostUsd
 	});
-	const maxReasoningTokens = config.maxReasoningTokens ?? maxOutputTokens * 4;
-	const maxModelRequestBytes = config.maxModelRequestBytes ?? 16777216;
-	const maxModelResponseBytes = config.maxModelResponseBytes ?? 4194304;
-	const modelRequestTimeoutMs = config.modelRequestTimeoutMs ?? timeoutMs;
-	const pricing = config.pricing ?? pricingForModel$2(model);
-	const costLedger = config.costLedger ?? new CostLedger();
-	const durability = config.durability ? {
-		runIdentitySha256: requiredString(config.durability.runIdentitySha256, "durability.runIdentitySha256"),
-		responseCacheDir: requiredString(config.durability.responseCacheDir, "durability.responseCacheDir")
+	return {
+		definition,
+		binding,
+		replyContract,
+		attributeByteCaps,
+		config,
+		model,
+		callRef,
+		maxOutputTokens,
+		maxCostUsd,
+		maxReasoningTokens: config.maxReasoningTokens ?? maxOutputTokens * 4,
+		maxModelRequestBytes: config.maxModelRequestBytes ?? 16777216,
+		maxModelResponseBytes: config.maxModelResponseBytes ?? 4194304,
+		modelRequestTimeoutMs: config.modelRequestTimeoutMs ?? timeoutMs,
+		pricing: config.pricing ?? pricingForModel$2(model),
+		costLedger: config.costLedger ?? new CostLedger(),
+		durability: config.durability ? {
+			runIdentitySha256: requiredString(config.durability.runIdentitySha256, "durability.runIdentitySha256"),
+			responseCacheDir: requiredString(config.durability.responseCacheDir, "durability.responseCacheDir")
+		} : void 0,
+		systemPrompt: [taskDefinition, ...replyContract.contractLines].join("\n\n")
+	};
+}
+/** The case's usage as the cost ledger has settled it so far. */
+function chunkedCaseUsage(arm, run) {
+	return usageReceiptFromCostLedger(arm.costLedger, {
+		channel: "analyst",
+		tags: run.costTags
+	});
+}
+/** The one JSON-mode, thinking-disabled request this case sends. */
+function buildChunkedRequest(arm, preparedContext) {
+	return {
+		model: arm.model,
+		messages: [{
+			role: "system",
+			content: arm.systemPrompt
+		}, {
+			role: "user",
+			content: arm.binding.userMessage(preparedContext)
+		}],
+		jsonMode: true,
+		thinking: "disabled",
+		maxTokens: arm.maxOutputTokens,
+		timeoutMs: arm.modelRequestTimeoutMs
+	};
+}
+/** Settle a durable-cache hit; returns the failed output when the cached call had failed. */
+function applyCachedResponse(arm, run, cached) {
+	const receipt = settleCachedResponse(arm.costLedger, cached);
+	run.modelMetadata = {
+		...run.modelMetadata,
+		responseSource: "durable-cache",
+		cost: costReceiptMetadata(receipt)
+	};
+	if (cached.status === "failed") return {
+		findings: [],
+		usage: chunkedCaseUsage(arm, run),
+		error: cached.error,
+		metadata: run.modelMetadata
+	};
+	const response = decodeReplyRows(arm.replyContract, cached.response);
+	run.rawPredictions = response.rows;
+	run.rejectedRows = response.rejected.map((entry) => entry.reason);
+	run.providerModel = cached.metadata.providerModel;
+	run.producedAt = cached.metadata.producedAt;
+	run.modelMetadata = {
+		...run.modelMetadata,
+		...response.extras,
+		providerModel: cached.metadata.providerModel,
+		providerDurationMs: cached.metadata.providerDurationMs,
+		finishReason: cached.metadata.finishReason
+	};
+}
+/** Make the one paid call through the model proxy, caching its response or its settled failure. */
+async function callChunkedThroughProxy(arm, context, modelProxy, request, cacheIdentity, providerCallId) {
+	const { costLedger, durability, replyContract } = arm;
+	const llmOptions = {
+		baseUrl: modelProxy.baseUrl,
+		apiKey: modelProxy.apiKey,
+		maximumAttempts: 1,
+		jsonSchemaTransport: "json-object",
+		jsonPayloadMode: "exact",
+		thinking: "disabled"
+	};
+	try {
+		const completed = await callLlmJson(request, {
+			...llmOptions,
+			...context.signal ? { signal: context.signal } : {},
+			idempotencyKey: providerCallId
+		});
+		const response = decodeReplyRows(replyContract, completed.value);
+		const responseProducedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const receipt = requiredSettledReceipt(costLedger, providerCallId);
+		if (cacheIdentity) writePublicBenchmarkResponseCache(durability.responseCacheDir, {
+			kind: "agent-eval/public-benchmark-model-response",
+			...cacheIdentity,
+			callId: providerCallId,
+			status: "succeeded",
+			response: completed.value,
+			metadata: {
+				providerModel: completed.result.model,
+				providerDurationMs: completed.result.durationMs,
+				finishReason: completed.result.finishReason ?? null,
+				producedAt: responseProducedAt
+			},
+			receipt: cacheReceiptInput(receipt)
+		});
+		modelProxy.assertExecutionComplete();
+		return {
+			...completed,
+			response,
+			producedAt: responseProducedAt,
+			receipt
+		};
+	} catch (error) {
+		const controlFailure = modelProxy.failures().find(isPaidCallControlError$1);
+		if (controlFailure) throw controlFailure;
+		const receipt = settledReceipt(costLedger, providerCallId);
+		if (cacheIdentity) {
+			if (receipt) writePublicBenchmarkResponseCache(durability.responseCacheDir, {
+				kind: "agent-eval/public-benchmark-model-response",
+				...cacheIdentity,
+				callId: providerCallId,
+				status: "failed",
+				error: publicBenchmarkError(error, []),
+				receipt: cacheReceiptInput(receipt)
+			});
+		}
+		throw error;
+	}
+}
+/** Call the provider once behind a budgeted loopback proxy and record the response on the case. */
+async function applyProviderResponse(arm, run, request, cacheIdentity, callId) {
+	const { binding, costLedger, config, callRef, model } = arm;
+	const { context } = run;
+	assertNoSettledResponseWithoutCache(costLedger, callId);
+	const providerCallId = callId ?? `analyst-benchmark-${randomUUID()}`;
+	let modelProxy;
+	const completed = await runWithCleanup({
+		label: "public benchmark direct model resources",
+		run: async () => {
+			modelProxy = await startExternalOptimizerModelProxy({
+				call: config.call,
+				callRef,
+				recordExecution: config.recordExecution,
+				model,
+				budget: {
+					maxCostUsd: arm.maxCostUsd,
+					maxRequests: 1,
+					maxRequestBytes: arm.maxModelRequestBytes,
+					maxResponseBytes: arm.maxModelResponseBytes,
+					maxOutputTokensPerRequest: arm.maxOutputTokens,
+					maxReasoningTokensPerRequest: arm.maxReasoningTokens,
+					pricing: arm.pricing,
+					requestTimeoutMs: arm.modelRequestTimeoutMs
+				},
+				costLedger,
+				channel: "analyst",
+				phase: binding.costPhase,
+				actor: binding.costActor,
+				tags: run.costTags,
+				callId: providerCallId,
+				...context.signal ? { signal: context.signal } : {}
+			});
+			return callChunkedThroughProxy(arm, context, modelProxy, request, cacheIdentity, providerCallId);
+		},
+		cleanup: async () => {
+			await modelProxy?.close();
+		}
+	});
+	const response = completed.response;
+	run.rawPredictions = response.rows;
+	run.rejectedRows = response.rejected.map((entry) => entry.reason);
+	run.providerModel = completed.result.model;
+	run.producedAt = completed.producedAt;
+	run.modelMetadata = {
+		...run.modelMetadata,
+		responseSource: "provider",
+		...response.extras,
+		providerModel: completed.result.model,
+		providerDurationMs: completed.result.durationMs,
+		finishReason: completed.result.finishReason ?? null,
+		cost: costReceiptMetadata(completed.receipt)
+	};
+}
+/** Expand the accepted rows into findings and ground them against the store. */
+async function expandChunkedFindings(arm, run, store) {
+	const { binding, definition } = arm;
+	const { context } = run;
+	const converted = await binding.expandRows({
+		subject: run.trajectoryId,
+		rows: run.rawPredictions,
+		store,
+		analystId: definition.id,
+		providerModel: run.providerModel,
+		producedAt: requiredString(run.producedAt ?? "", "finding producedAt"),
+		...context.signal ? { signal: context.signal } : {}
+	});
+	run.modelFindings = converted.findings;
+	if (converted.diagnostics) run.modelMetadata = {
+		...run.modelMetadata,
+		blockDiagnostics: {
+			...converted.diagnostics,
+			rejectedBlocks: run.rejectedRows
+		}
+	};
+	if (binding.verifyFindings) await binding.verifyFindings({
+		subject: run.trajectoryId,
+		findings: run.modelFindings,
+		store,
+		...context.signal ? { signal: context.signal } : {}
+	});
+}
+/** Answer one case from the durable cache or the provider, then expand and ground its findings. */
+async function analyzeChunkedRows(arm, run, store) {
+	const { context, trajectoryId } = run;
+	const preparedContext = await prepareSingleTraceContext(store, context, arm.attributeByteCaps);
+	if (preparedContext === void 0) throw new Error(`trace '${trajectoryId}' has no readable spans`);
+	const request = buildChunkedRequest(arm, preparedContext);
+	const cacheIdentity = arm.durability ? {
+		runIdentitySha256: arm.durability.runIdentitySha256,
+		caseId: context.caseId,
+		repetition: context.repetition
 	} : void 0;
-	const systemPrompt = [definition.taskDefinition, ...replyContract.contractLines].join("\n\n");
+	const callId = cacheIdentity ? publicBenchmarkCallId(cacheIdentity) : void 0;
+	const cached = cacheIdentity ? readPublicBenchmarkResponseCache(arm.durability.responseCacheDir, cacheIdentity) : void 0;
+	if (cached) {
+		const failed = applyCachedResponse(arm, run, cached);
+		if (failed) return failed;
+	} else await applyProviderResponse(arm, run, request, cacheIdentity, callId);
+	await expandChunkedFindings(arm, run, store);
 	return {
-		id: definition.id,
-		async analyze(input, context) {
-			const trajectoryId = binding.subjectFromCaseId(context.caseId);
-			const costTags = {
-				analystId: binding.costActor,
-				benchmarkCaseId: context.caseId,
-				benchmarkRepetition: String(context.repetition)
-			};
-			let rawPredictions = [];
-			let rejectedRows = [];
-			let modelFindings = [];
-			let providerModel = model;
-			let producedAt;
-			let modelMetadata = {
-				...binding.baseMetadata,
-				protocolSha256: definition.protocolSha256,
-				callRef
-			};
-			try {
-				if (!input.traceStore) throw new Error(`chunked analyst '${definition.id}' requires a trace store`);
-				const preparedContext = await prepareSingleTraceContext(input.traceStore, context, projection.attributeByteCaps);
-				if (preparedContext === void 0) throw new Error(`trace '${trajectoryId}' has no readable spans`);
-				const request = {
-					model,
-					messages: [{
-						role: "system",
-						content: systemPrompt
-					}, {
-						role: "user",
-						content: binding.userMessage(preparedContext)
-					}],
-					jsonMode: true,
-					thinking: "disabled",
-					maxTokens: maxOutputTokens,
-					timeoutMs: modelRequestTimeoutMs
-				};
-				const cacheIdentity = durability ? {
-					runIdentitySha256: durability.runIdentitySha256,
-					caseId: context.caseId,
-					repetition: context.repetition
-				} : void 0;
-				const callId = cacheIdentity ? publicBenchmarkCallId(cacheIdentity) : void 0;
-				const cached = cacheIdentity ? readPublicBenchmarkResponseCache(durability.responseCacheDir, cacheIdentity) : void 0;
-				if (cached) {
-					const receipt = settleCachedResponse(costLedger, cached);
-					modelMetadata = {
-						...modelMetadata,
-						responseSource: "durable-cache",
-						cost: costReceiptMetadata(receipt)
-					};
-					if (cached.status === "failed") return {
-						findings: [],
-						usage: usageReceiptFromCostLedger(costLedger, {
-							channel: "analyst",
-							tags: costTags
-						}),
-						error: cached.error,
-						metadata: modelMetadata
-					};
-					const response = decodeReplyRows(replyContract, cached.response);
-					rawPredictions = response.rows;
-					rejectedRows = response.rejected.map((entry) => entry.reason);
-					providerModel = cached.metadata.providerModel;
-					producedAt = cached.metadata.producedAt;
-					modelMetadata = {
-						...modelMetadata,
-						...response.extras,
-						providerModel: cached.metadata.providerModel,
-						providerDurationMs: cached.metadata.providerDurationMs,
-						finishReason: cached.metadata.finishReason
-					};
-				} else {
-					assertNoSettledResponseWithoutCache(costLedger, callId);
-					const providerCallId = callId ?? `analyst-benchmark-${randomUUID()}`;
-					let modelProxy;
-					const completed = await runWithCleanup({
-						label: "public benchmark direct model resources",
-						run: async () => {
-							modelProxy = await startExternalOptimizerModelProxy({
-								call: config.call,
-								callRef,
-								recordExecution: config.recordExecution,
-								model,
-								budget: {
-									maxCostUsd,
-									maxRequests: 1,
-									maxRequestBytes: maxModelRequestBytes,
-									maxResponseBytes: maxModelResponseBytes,
-									maxOutputTokensPerRequest: maxOutputTokens,
-									maxReasoningTokensPerRequest: maxReasoningTokens,
-									pricing,
-									requestTimeoutMs: modelRequestTimeoutMs
-								},
-								costLedger,
-								channel: "analyst",
-								phase: binding.costPhase,
-								actor: binding.costActor,
-								tags: costTags,
-								callId: providerCallId,
-								...context.signal ? { signal: context.signal } : {}
-							});
-							const llmOptions = {
-								baseUrl: modelProxy.baseUrl,
-								apiKey: modelProxy.apiKey,
-								maximumAttempts: 1,
-								jsonSchemaTransport: "json-object",
-								jsonPayloadMode: "exact",
-								thinking: "disabled"
-							};
-							try {
-								const completed = await callLlmJson(request, {
-									...llmOptions,
-									...context.signal ? { signal: context.signal } : {},
-									idempotencyKey: providerCallId
-								});
-								const response = decodeReplyRows(replyContract, completed.value);
-								const responseProducedAt = (/* @__PURE__ */ new Date()).toISOString();
-								const receipt = requiredSettledReceipt(costLedger, providerCallId);
-								if (cacheIdentity) writePublicBenchmarkResponseCache(durability.responseCacheDir, {
-									kind: "agent-eval/public-benchmark-model-response",
-									...cacheIdentity,
-									callId: providerCallId,
-									status: "succeeded",
-									response: completed.value,
-									metadata: {
-										providerModel: completed.result.model,
-										providerDurationMs: completed.result.durationMs,
-										finishReason: completed.result.finishReason ?? null,
-										producedAt: responseProducedAt
-									},
-									receipt: cacheReceiptInput(receipt)
-								});
-								modelProxy.assertExecutionComplete();
-								return {
-									...completed,
-									response,
-									producedAt: responseProducedAt,
-									receipt
-								};
-							} catch (error) {
-								const controlFailure = modelProxy.failures().find(isPaidCallControlError$1);
-								if (controlFailure) throw controlFailure;
-								const receipt = settledReceipt(costLedger, providerCallId);
-								if (cacheIdentity) {
-									if (receipt) writePublicBenchmarkResponseCache(durability.responseCacheDir, {
-										kind: "agent-eval/public-benchmark-model-response",
-										...cacheIdentity,
-										callId: providerCallId,
-										status: "failed",
-										error: publicBenchmarkError(error, []),
-										receipt: cacheReceiptInput(receipt)
-									});
-								}
-								throw error;
-							}
-						},
-						cleanup: async () => {
-							await modelProxy?.close();
-						}
-					});
-					const response = completed.response;
-					rawPredictions = response.rows;
-					rejectedRows = response.rejected.map((entry) => entry.reason);
-					providerModel = completed.result.model;
-					producedAt = completed.producedAt;
-					modelMetadata = {
-						...modelMetadata,
-						responseSource: "provider",
-						...response.extras,
-						providerModel: completed.result.model,
-						providerDurationMs: completed.result.durationMs,
-						finishReason: completed.result.finishReason ?? null,
-						cost: costReceiptMetadata(completed.receipt)
-					};
-				}
-				const converted = await binding.expandRows({
-					subject: trajectoryId,
-					rows: rawPredictions,
-					store: input.traceStore,
-					analystId: definition.id,
-					providerModel,
-					producedAt: requiredString(producedAt ?? "", "finding producedAt"),
-					...context.signal ? { signal: context.signal } : {}
-				});
-				modelFindings = converted.findings;
-				if (converted.diagnostics) modelMetadata = {
-					...modelMetadata,
-					blockDiagnostics: {
-						...converted.diagnostics,
-						rejectedBlocks: rejectedRows
-					}
-				};
-				if (binding.verifyFindings) await binding.verifyFindings({
-					subject: trajectoryId,
-					findings: modelFindings,
-					store: input.traceStore,
-					...context.signal ? { signal: context.signal } : {}
-				});
-				return {
-					findings: modelFindings,
-					usage: usageReceiptFromCostLedger(costLedger, {
-						channel: "analyst",
-						tags: costTags
-					}),
-					metadata: modelMetadata
-				};
-			} catch (error) {
-				if (context.signal?.aborted) throw error;
-				if (isPaidCallControlError$1(error)) throw error;
-				return {
-					findings: [],
-					usage: usageReceiptFromCostLedger(costLedger, {
-						channel: "analyst",
-						tags: costTags
-					}),
-					error: publicBenchmarkError(error, []),
-					metadata: {
-						...modelMetadata,
-						rawPredictions,
-						acceptedFindings: modelFindings
-					}
-				};
-			}
+		findings: run.modelFindings,
+		usage: chunkedCaseUsage(arm, run),
+		metadata: run.modelMetadata
+	};
+}
+/** Analyze one benchmark case; a paid-call control error or an abort is rethrown, any other failure is recorded. */
+async function analyzeChunkedCase(arm, input, context) {
+	const { definition, binding } = arm;
+	const run = {
+		context,
+		trajectoryId: binding.subjectFromCaseId(context.caseId),
+		costTags: {
+			analystId: binding.costActor,
+			benchmarkCaseId: context.caseId,
+			benchmarkRepetition: String(context.repetition)
+		},
+		rawPredictions: [],
+		rejectedRows: [],
+		modelFindings: [],
+		providerModel: arm.model,
+		producedAt: void 0,
+		modelMetadata: {
+			...binding.baseMetadata,
+			protocolSha256: definition.protocolSha256,
+			callRef: arm.callRef
 		}
 	};
+	try {
+		if (!input.traceStore) throw new Error(`chunked analyst '${definition.id}' requires a trace store`);
+		return await analyzeChunkedRows(arm, run, input.traceStore);
+	} catch (error) {
+		if (context.signal?.aborted) throw error;
+		if (isPaidCallControlError$1(error)) throw error;
+		return {
+			findings: [],
+			usage: chunkedCaseUsage(arm, run),
+			error: publicBenchmarkError(error, []),
+			metadata: {
+				...run.modelMetadata,
+				rawPredictions: run.rawPredictions,
+				acceptedFindings: run.modelFindings
+			}
+		};
+	}
+}
+/**
+* Compile a chunked-projection definition into a runnable one-shot JSON arm
+* over the caller-owned model path. Prompt content, the projection ladder,
+* the reply grammar, and the budget declaration come from the definition;
+* caching, cost settlement, and the model proxy are transport machinery.
+*/
+function runChunkedAnalystDefinition(definition, config) {
+	const arm = compileChunkedArm(definition, config);
+	return {
+		id: definition.id,
+		analyze: (input, context) => analyzeChunkedCase(arm, input, context)
+	};
 }
 /** A definition that declares one budget while the transport runs another is refused. */
 function assertDeclaredBudget(definition, effective) {
@@ -4610,6 +4596,101 @@ function pricingForModel$2(model) {
 		outputUsdPerMillion: pricing.output * 1e3
 	};
 }
+async function prepareSingleTraceContext(store, context, attributeByteCaps) {
+	const storeContext = context.signal ? { signal: context.signal } : void 0;
+	const overview = await store.getOverview(void 0, storeContext);
+	if (overview.total_traces !== 1 || overview.sample_trace_ids.length !== 1) throw new Error(`public model benchmark requires exactly one trace, received ${overview.total_traces}`);
+	const traceId = overview.sample_trace_ids[0];
+	for (const perAttributeByteCap of attributeByteCaps) {
+		const viewed = await store.viewTrace({
+			trace_id: traceId,
+			per_attribute_byte_cap: perAttributeByteCap
+		}, storeContext);
+		if (!viewed.spans) continue;
+		return JSON.stringify({
+			trace_id: traceId,
+			per_attribute_byte_cap: perAttributeByteCap,
+			spans: viewed.spans
+		});
+	}
+}
+//#endregion
+//#region src/analyst/benchmark-public-model.ts
+/** The direct arm as a declarative unit for one public dataset. */
+function publicDirectAnalystDefinition(dataset, args) {
+	const actor = dataset === "agentrx" ? "agentrx-root-cause-localizer" : "codetracebench-step-localizer";
+	const outputAdapter = dataset === "agentrx" ? "agentrx-taxonomy-and-root-step" : "codetracebench-incorrect-block";
+	return {
+		id: "direct",
+		description: "One-shot JSON baseline over the caller-owned model path.",
+		version: "1.0.0",
+		area: dataset === "agentrx" ? "root-cause" : "incorrect",
+		profile: { model: { reasoningEffort: "none" } },
+		question: "",
+		taskDefinition: publicBenchmarkTaskPrompt(dataset),
+		projection: {
+			mode: "chunked",
+			attributeByteCaps: TRACE_PROJECTION_ATTRIBUTE_BYTE_CAPS
+		},
+		replyContract: directReplyContract(dataset),
+		contractLimits: dataset === "agentrx" ? { maxFindings: 1 } : {
+			maxBlocks: 16,
+			maxBlockSteps: 12
+		},
+		budget: {
+			timeoutMs: args.timeoutMs,
+			maxCostUsd: args.maxCostUsd,
+			maxOutputTokens: args.maxOutputTokens
+		},
+		repair: { turns: 0 },
+		protocolSha256: publicBenchmarkProtocolSha256(dataset),
+		binding: {
+			kind: "chunked",
+			subjectFromCaseId: (caseId) => trajectoryIdFromCaseId$2(dataset, caseId),
+			baseMetadata: {
+				analysisMode: "direct-baseline",
+				outputAdapter
+			},
+			costActor: actor,
+			costPhase: "analyst.public-benchmark",
+			userMessage: (rendered) => `TRACE DATA:\n${rendered}\n\nReturn the analysis JSON object.`,
+			async expandRows({ subject, rows, store, analystId, producedAt, providerModel, signal }) {
+				const converted = await publicBenchmarkPredictionsToFindings({
+					dataset,
+					trajectoryId: subject,
+					predictions: rows,
+					store,
+					analystId,
+					providerModel: requiredString(providerModel ?? "", "finding providerModel"),
+					producedAt: requiredString(producedAt ?? "", "finding producedAt"),
+					...signal ? { signal } : {}
+				});
+				return {
+					findings: converted.findings,
+					diagnostics: converted.diagnostics
+				};
+			},
+			...dataset === "codetracebench" ? { verifyFindings: async (args) => {
+				await validateCodeTraceFindingEvidence({
+					trajectoryId: args.subject,
+					findings: [...args.findings],
+					store: args.store,
+					...args.signal ? { signal: args.signal } : {}
+				});
+			} } : {}
+		}
+	};
+}
+/** Thin shell: validate config, declare the definition, run the chunked strategy. */
+function createPublicBenchmarkDirectRunner(dataset, config) {
+	if (config.instructionsOverride) throw new Error("the direct runner executes only the stock protocol; an instructions override requires the dspy-rlm runner");
+	const maxOutputTokens = positiveSafeInteger(config.maxOutputTokens, "maxOutputTokens");
+	return runChunkedAnalystDefinition(publicDirectAnalystDefinition(dataset, {
+		timeoutMs: positiveSafeInteger(config.timeoutMs, "timeoutMs"),
+		maxOutputTokens,
+		maxCostUsd: config.maxCostUsdPerAnalysis ?? 1
+	}), config);
+}
 const ModelSeveritySchema = z.enum([
 	"critical",
 	"high",
@@ -4789,24 +4870,6 @@ async function publicBenchmarkPredictionsToFindings(options) {
 		...options.signal ? { signal: options.signal } : {}
 	});
 }
-async function prepareSingleTraceContext(store, context, attributeByteCaps) {
-	const storeContext = context.signal ? { signal: context.signal } : void 0;
-	const overview = await store.getOverview(void 0, storeContext);
-	if (overview.total_traces !== 1 || overview.sample_trace_ids.length !== 1) throw new Error(`public model benchmark requires exactly one trace, received ${overview.total_traces}`);
-	const traceId = overview.sample_trace_ids[0];
-	for (const perAttributeByteCap of attributeByteCaps) {
-		const viewed = await store.viewTrace({
-			trace_id: traceId,
-			per_attribute_byte_cap: perAttributeByteCap
-		}, storeContext);
-		if (!viewed.spans) continue;
-		return JSON.stringify({
-			trace_id: traceId,
-			per_attribute_byte_cap: perAttributeByteCap,
-			spans: viewed.spans
-		});
-	}
-}
 function trajectoryIdFromCaseId$2(dataset, caseId) {
 	const prefix = dataset === "agentrx" ? "agentrx:" : "codetrace:";
 	if (!caseId.startsWith(prefix) || caseId.length === prefix.length) throw new Error(`unexpected ${dataset} benchmark case id '${caseId}'`);
@@ -5072,13 +5135,8 @@ function rlmEngineLimits(config) {
 		maxOutputChars: config.dspyRlm?.maxOutputChars ?? 8e3
 	};
 }
-/**
-* Compile a repl-variable definition into a runnable recursive-engine arm over
-* the caller-owned model path. The question, instructions, tool group, and
-* iteration limits come from the definition; the engine, model proxy, sampling
-* loop, and abstention floor are transport machinery.
-*/
-function runReplVariableAnalystDefinition(definition, config) {
+/** Refuse a definition or transport the repl-variable strategy cannot execute exactly as declared. */
+function checkReplVariableDefinition(definition, config) {
 	const { projection, binding } = definition;
 	if (projection.mode !== "repl-variable" || binding.kind !== "repl-variable") throw new AnalystExpressivenessError(`the repl-variable strategy compiles only repl-variable projections; definition '${definition.id}' declares projection '${projection.mode}' with a '${binding.kind}' binding`);
 	const instructions = definition.taskDefinition;
@@ -5090,12 +5148,17 @@ function runReplVariableAnalystDefinition(definition, config) {
 	if (limits === void 0) throw new AnalystExpressivenessError(`the repl-variable strategy needs declared engine limits; definition '${definition.id}' declares none`);
 	const effectiveLimits = rlmEngineLimits(config);
 	if (limits.maxIterations !== effectiveLimits.maxIterations || limits.maxLlmCalls !== effectiveLimits.maxLlmCalls || limits.maxToolCalls !== effectiveLimits.maxToolCalls || limits.maxOutputChars !== effectiveLimits.maxOutputChars) throw new AnalystExpressivenessError(`definition '${definition.id}' declares engine limits ${JSON.stringify(limits)} but the bound transport runs ${JSON.stringify(effectiveLimits)}; the declaration must state what executes`);
-	const costLedger = config.costLedger ?? new CostLedger();
-	const samples = config.dspyRlm?.samples ?? 1;
-	if (!Number.isSafeInteger(samples) || samples < 1) throw new RangeError("dspyRlm.samples must be a positive safe integer");
-	if (samples > 1 && binding.consensus === void 0) throw new AnalystExpressivenessError(`samples > 1 needs a consensus port; definition '${definition.id}' declares none`);
-	const pricing = config.pricing ?? pricingForModel$1(config.model);
-	const engine = createDspyRlmTraceEngine({
+	return {
+		binding,
+		instructions,
+		area,
+		limits,
+		toolGroup: projection.toolGroup
+	};
+}
+/** The recursive engine over the caller-owned model path, with only the configured options set. */
+function createReplVariableEngine(config, pricing) {
+	return createDspyRlmTraceEngine({
 		call: config.call,
 		callRef: config.callRef,
 		recordExecution: config.recordExecution,
@@ -5116,7 +5179,15 @@ function runReplVariableAnalystDefinition(definition, config) {
 		...config.dspyRlm?.traceToolTimeoutMs === void 0 ? {} : { traceToolTimeoutMs: config.dspyRlm.traceToolTimeoutMs },
 		...config.dspyRlm?.runner ? { runner: config.dspyRlm.runner } : {}
 	});
-	const protocolSha256 = definition.protocolSha256;
+}
+/** Validate the definition and transport, then build the engine, ledger and abstention floor. */
+function compileReplVariableArm(definition, config) {
+	const { binding, instructions, area, limits, toolGroup } = checkReplVariableDefinition(definition, config);
+	const costLedger = config.costLedger ?? new CostLedger();
+	const samples = config.dspyRlm?.samples ?? 1;
+	if (!Number.isSafeInteger(samples) || samples < 1) throw new RangeError("dspyRlm.samples must be a positive safe integer");
+	if (samples > 1 && binding.consensus === void 0) throw new AnalystExpressivenessError(`samples > 1 needs a consensus port; definition '${definition.id}' declares none`);
+	const engine = createReplVariableEngine(config, config.pricing ?? pricingForModel$1(config.model));
 	const traceDefinition = {
 		id: binding.traceAnalystId,
 		description: definition.description,
@@ -5124,218 +5195,246 @@ function runReplVariableAnalystDefinition(definition, config) {
 		version: definition.version,
 		question: definition.question,
 		instructions,
-		toolGroup: projection.toolGroup,
+		toolGroup,
 		limits
 	};
 	const { instructionsOverride: _rlmOnlyOverride, ...directConfig } = config;
-	const abstentionFallbackRunner = binding.abstentionFallback({
-		...directConfig,
-		costLedger
+	return {
+		definition,
+		binding,
+		config,
+		area,
+		samples,
+		costLedger,
+		engine,
+		traceDefinition,
+		abstentionFallbackRunner: binding.abstentionFallback({
+			...directConfig,
+			costLedger
+		})
+	};
+}
+/** Stamp the engine's raw rows as findings; `extra` metadata sits between the model and the subject block. */
+function stampFindings(arm, rows, extra) {
+	const { definition, binding, config, area } = arm;
+	const producedAt = (/* @__PURE__ */ new Date()).toISOString();
+	return rows.map((finding) => makeFinding({
+		analyst_id: definition.id,
+		area,
+		subject: finding.subject,
+		claim: finding.claim,
+		rationale: finding.rationale,
+		severity: finding.severity,
+		confidence: finding.confidence,
+		evidence_refs: evidenceRefsFromRawFinding(finding),
+		recommended_action: finding.recommended_action,
+		metadata: {
+			...binding.findingBaseMetadata,
+			model: config.model,
+			...extra,
+			...binding.metadataFromSubject?.(finding.subject) ?? {}
+		},
+		produced_at: producedAt
+	}));
+}
+/** Metadata that records a direct abstention-floor call, or nothing when none fired. */
+function abstentionFallbackMetadata(fallback) {
+	if (!fallback) return {};
+	return {
+		abstentionFallback: "direct",
+		...fallback.metadata ? { abstentionFallbackMetadata: fallback.metadata } : {},
+		...fallback.error ? { abstentionFallbackError: fallback.error } : {}
+	};
+}
+/** Run one engine sample of a multi-sample case and fold it into the totals. */
+async function runReplVariableSample(arm, run, store, sample, totals) {
+	const { definition, binding, costLedger } = arm;
+	const { context, tags } = run;
+	const caseUsageFilter = {
+		channel: "analyst",
+		tags
+	};
+	let sampleUsage;
+	const completed = await runTraceAnalyst({
+		definition: arm.traceDefinition,
+		engine: arm.engine,
+		store,
+		context: {
+			runId: context.caseId,
+			correlationId: `${context.caseId}:${context.repetition}:sample-${sample}`,
+			costLedger,
+			costPhase: binding.costPhase,
+			tags,
+			recordUsage: (receipt) => {
+				sampleUsage = receipt;
+				run.usage = usageReceiptFromCostLedger(costLedger, caseUsageFilter);
+			},
+			signal: context.signal
+		}
+	});
+	const sampleFindings = stampFindings(arm, completed.findings, { sample });
+	run.rawFindings = [...run.rawFindings, ...sampleFindings];
+	const adapted = await binding.adapt({
+		subject: run.trajectoryId,
+		findings: sampleFindings,
+		analystId: definition.id,
+		store,
+		...context.signal ? { signal: context.signal } : {}
+	});
+	const assignments = adapted.stepBlocks ?? [];
+	totals.sampleAssignments.push(assignments);
+	totals.modelCalls += completed.modelCalls;
+	totals.toolCalls += completed.toolCalls;
+	totals.sampleRuns.push({
+		sample,
+		answer: completed.answer,
+		trajectory: completed.trajectory,
+		modelCalls: completed.modelCalls,
+		toolCalls: completed.toolCalls,
+		runtime: completed.runtime,
+		...binding.consensus.sampleRecord(assignments),
+		...adapted.diagnostics ? { blockDiagnostics: adapted.diagnostics } : {},
+		...sampleUsage ? { usage: sampleUsage } : {}
+	});
+}
+/** Run k samples, vote on their step blocks, and fall back only when the whole panel found nothing. */
+async function analyzeReplVariableSamples(arm, run, input, store) {
+	const { definition, binding, costLedger, samples } = arm;
+	const { context } = run;
+	const totals = {
+		sampleRuns: [],
+		sampleAssignments: [],
+		modelCalls: 0,
+		toolCalls: 0
+	};
+	for (let sample = 0; sample < samples; sample += 1) await runReplVariableSample(arm, run, store, sample, totals);
+	const consensus = binding.consensus.vote(totals.sampleAssignments);
+	const expanded = await binding.consensus.expand({
+		subject: run.trajectoryId,
+		blocks: consensus.blocks,
+		store,
+		analystId: definition.id,
+		producedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...context.signal ? { signal: context.signal } : {}
+	});
+	let fallback;
+	if (consensus.blocks.length === 0) fallback = await arm.abstentionFallbackRunner.analyze(input, context);
+	run.usage = usageReceiptFromCostLedger(costLedger, {
+		channel: "analyst",
+		tags: run.tags
 	});
 	return {
-		id: definition.id,
-		async analyze(input, context) {
-			const trajectoryId = binding.subjectFromCaseId(context.caseId);
-			const tags = {
-				benchmarkCaseId: context.caseId,
-				benchmarkRepetition: String(context.repetition)
-			};
-			let usage;
-			let rawFindings = [];
-			try {
-				if (!input.traceStore) throw new Error(`repl-variable analyst '${definition.id}' requires a trace store`);
-				if (samples > 1) {
-					const store = input.traceStore;
-					const caseUsageFilter = {
-						channel: "analyst",
-						tags
-					};
-					const sampleRuns = [];
-					const sampleAssignments = [];
-					let totalModelCalls = 0;
-					let totalToolCalls = 0;
-					for (let sample = 0; sample < samples; sample += 1) {
-						let sampleUsage;
-						const completed = await runTraceAnalyst({
-							definition: traceDefinition,
-							engine,
-							store,
-							context: {
-								runId: context.caseId,
-								correlationId: `${context.caseId}:${context.repetition}:sample-${sample}`,
-								costLedger,
-								costPhase: binding.costPhase,
-								tags,
-								recordUsage: (receipt) => {
-									sampleUsage = receipt;
-									usage = usageReceiptFromCostLedger(costLedger, caseUsageFilter);
-								},
-								signal: context.signal
-							}
-						});
-						const producedAt = (/* @__PURE__ */ new Date()).toISOString();
-						const sampleFindings = completed.findings.map((finding) => makeFinding({
-							analyst_id: definition.id,
-							area,
-							subject: finding.subject,
-							claim: finding.claim,
-							rationale: finding.rationale,
-							severity: finding.severity,
-							confidence: finding.confidence,
-							evidence_refs: evidenceRefsFromRawFinding(finding),
-							recommended_action: finding.recommended_action,
-							metadata: {
-								...binding.findingBaseMetadata,
-								model: config.model,
-								sample,
-								...binding.metadataFromSubject?.(finding.subject) ?? {}
-							},
-							produced_at: producedAt
-						}));
-						rawFindings = [...rawFindings, ...sampleFindings];
-						const adapted = await binding.adapt({
-							subject: trajectoryId,
-							findings: sampleFindings,
-							analystId: definition.id,
-							store,
-							...context.signal ? { signal: context.signal } : {}
-						});
-						const assignments = adapted.stepBlocks ?? [];
-						sampleAssignments.push(assignments);
-						totalModelCalls += completed.modelCalls;
-						totalToolCalls += completed.toolCalls;
-						sampleRuns.push({
-							sample,
-							answer: completed.answer,
-							trajectory: completed.trajectory,
-							modelCalls: completed.modelCalls,
-							toolCalls: completed.toolCalls,
-							runtime: completed.runtime,
-							...binding.consensus.sampleRecord(assignments),
-							...adapted.diagnostics ? { blockDiagnostics: adapted.diagnostics } : {},
-							...sampleUsage ? { usage: sampleUsage } : {}
-						});
-					}
-					const consensus = binding.consensus.vote(sampleAssignments);
-					const expanded = await binding.consensus.expand({
-						subject: trajectoryId,
-						blocks: consensus.blocks,
-						store,
-						analystId: definition.id,
-						producedAt: (/* @__PURE__ */ new Date()).toISOString(),
-						...context.signal ? { signal: context.signal } : {}
-					});
-					let fallback;
-					if (consensus.blocks.length === 0) fallback = await abstentionFallbackRunner.analyze(input, context);
-					usage = usageReceiptFromCostLedger(costLedger, caseUsageFilter);
-					return {
-						findings: fallback && !fallback.error ? fallback.findings : expanded.findings,
-						usage,
-						metadata: {
-							...binding.baseMetadata,
-							protocolSha256,
-							samples,
-							sampleRuns,
-							consensus: consensus.decision,
-							blockDiagnostics: expanded.diagnostics,
-							modelCalls: totalModelCalls,
-							toolCalls: totalToolCalls,
-							...fallback ? {
-								abstentionFallback: "direct",
-								...fallback.metadata ? { abstentionFallbackMetadata: fallback.metadata } : {},
-								...fallback.error ? { abstentionFallbackError: fallback.error } : {}
-							} : {}
-						}
-					};
-				}
-				const completed = await runTraceAnalyst({
-					definition: traceDefinition,
-					engine,
-					store: input.traceStore,
-					context: {
-						runId: context.caseId,
-						correlationId: `${context.caseId}:${context.repetition}`,
-						costLedger,
-						costPhase: binding.costPhase,
-						tags,
-						recordUsage: (receipt) => {
-							usage = receipt;
-						},
-						signal: context.signal
-					}
-				});
-				const producedAt = (/* @__PURE__ */ new Date()).toISOString();
-				rawFindings = completed.findings.map((finding) => makeFinding({
-					analyst_id: definition.id,
-					area,
-					subject: finding.subject,
-					claim: finding.claim,
-					rationale: finding.rationale,
-					severity: finding.severity,
-					confidence: finding.confidence,
-					evidence_refs: evidenceRefsFromRawFinding(finding),
-					recommended_action: finding.recommended_action,
-					metadata: {
-						...binding.findingBaseMetadata,
-						model: config.model,
-						...binding.metadataFromSubject?.(finding.subject) ?? {}
-					},
-					produced_at: producedAt
-				}));
-				const adapted = await binding.adapt({
-					subject: trajectoryId,
-					findings: rawFindings,
-					analystId: definition.id,
-					store: input.traceStore,
-					...context.signal ? { signal: context.signal } : {}
-				});
-				let fallback;
-				if (completed.findings.length === 0) {
-					fallback = await abstentionFallbackRunner.analyze(input, context);
-					usage = usageReceiptFromCostLedger(costLedger, {
-						channel: "analyst",
-						tags: {
-							benchmarkCaseId: context.caseId,
-							benchmarkRepetition: String(context.repetition)
-						}
-					});
-				}
-				return {
-					findings: fallback && !fallback.error ? fallback.findings : adapted.findings,
-					usage,
-					metadata: {
-						...binding.baseMetadata,
-						protocolSha256,
-						...adapted.diagnostics ? { blockDiagnostics: adapted.diagnostics } : {},
-						answer: completed.answer,
-						trajectory: completed.trajectory,
-						modelCalls: completed.modelCalls,
-						toolCalls: completed.toolCalls,
-						runtime: completed.runtime,
-						...fallback ? {
-							abstentionFallback: "direct",
-							...fallback.metadata ? { abstentionFallbackMetadata: fallback.metadata } : {},
-							...fallback.error ? { abstentionFallbackError: fallback.error } : {}
-						} : {}
-					}
-				};
-			} catch (error) {
-				if (context.signal?.aborted) throw error;
-				if (isPaidCallControlError(error)) throw error;
-				return {
-					findings: [],
-					usage,
-					error: publicBenchmarkError(error, []),
-					metadata: {
-						...binding.baseMetadata,
-						...samples > 1 ? { samples } : {},
-						rawFindings
-					}
-				};
-			}
+		findings: fallback && !fallback.error ? fallback.findings : expanded.findings,
+		usage: run.usage,
+		metadata: {
+			...binding.baseMetadata,
+			protocolSha256: definition.protocolSha256,
+			samples,
+			sampleRuns: totals.sampleRuns,
+			consensus: consensus.decision,
+			blockDiagnostics: expanded.diagnostics,
+			modelCalls: totals.modelCalls,
+			toolCalls: totals.toolCalls,
+			...abstentionFallbackMetadata(fallback)
 		}
 	};
 }
+/** Run the engine once, adapt its rows, and fall back only when it submitted no finding. */
+async function analyzeReplVariableOnce(arm, run, input, store) {
+	const { definition, binding, costLedger } = arm;
+	const { context, tags } = run;
+	const completed = await runTraceAnalyst({
+		definition: arm.traceDefinition,
+		engine: arm.engine,
+		store,
+		context: {
+			runId: context.caseId,
+			correlationId: `${context.caseId}:${context.repetition}`,
+			costLedger,
+			costPhase: binding.costPhase,
+			tags,
+			recordUsage: (receipt) => {
+				run.usage = receipt;
+			},
+			signal: context.signal
+		}
+	});
+	run.rawFindings = stampFindings(arm, completed.findings, {});
+	const adapted = await binding.adapt({
+		subject: run.trajectoryId,
+		findings: run.rawFindings,
+		analystId: definition.id,
+		store,
+		...context.signal ? { signal: context.signal } : {}
+	});
+	let fallback;
+	if (completed.findings.length === 0) {
+		fallback = await arm.abstentionFallbackRunner.analyze(input, context);
+		run.usage = usageReceiptFromCostLedger(costLedger, {
+			channel: "analyst",
+			tags
+		});
+	}
+	return {
+		findings: fallback && !fallback.error ? fallback.findings : adapted.findings,
+		usage: run.usage,
+		metadata: {
+			...binding.baseMetadata,
+			protocolSha256: definition.protocolSha256,
+			...adapted.diagnostics ? { blockDiagnostics: adapted.diagnostics } : {},
+			answer: completed.answer,
+			trajectory: completed.trajectory,
+			modelCalls: completed.modelCalls,
+			toolCalls: completed.toolCalls,
+			runtime: completed.runtime,
+			...abstentionFallbackMetadata(fallback)
+		}
+	};
+}
+/** Analyze one benchmark case; a paid-call control error or an abort is rethrown, any other failure is recorded. */
+async function analyzeReplVariableCase(arm, input, context) {
+	const { definition, binding, samples } = arm;
+	const run = {
+		context,
+		trajectoryId: binding.subjectFromCaseId(context.caseId),
+		tags: {
+			benchmarkCaseId: context.caseId,
+			benchmarkRepetition: String(context.repetition)
+		},
+		usage: void 0,
+		rawFindings: []
+	};
+	try {
+		if (!input.traceStore) throw new Error(`repl-variable analyst '${definition.id}' requires a trace store`);
+		return samples > 1 ? await analyzeReplVariableSamples(arm, run, input, input.traceStore) : await analyzeReplVariableOnce(arm, run, input, input.traceStore);
+	} catch (error) {
+		if (context.signal?.aborted) throw error;
+		if (isPaidCallControlError(error)) throw error;
+		return {
+			findings: [],
+			usage: run.usage,
+			error: publicBenchmarkError(error, []),
+			metadata: {
+				...binding.baseMetadata,
+				...samples > 1 ? { samples } : {},
+				rawFindings: run.rawFindings
+			}
+		};
+	}
+}
+/**
+* Compile a repl-variable definition into a runnable recursive-engine arm over
+* the caller-owned model path. The question, instructions, tool group, and
+* iteration limits come from the definition; the engine, model proxy, sampling
+* loop, and abstention floor are transport machinery.
+*/
+function runReplVariableAnalystDefinition(definition, config) {
+	const arm = compileReplVariableArm(definition, config);
+	return {
+		id: definition.id,
+		analyze: (input, context) => analyzeReplVariableCase(arm, input, context)
+	};
+}
 /** Per-sample accepted blocks with the exact steps the expansion kept for each. */
 function sampleBlockRecords(assignments) {
 	const stepsByBlock = /* @__PURE__ */ new Map();
@@ -6791,4 +6890,4 @@ function shellQuote(value) {
 //#endregion
 export { agentRxBenchmarkCase as A, ANALYST_BENCHMARK_COST_LEDGER_FILE as C, AGENT_RX_UPSTREAM_REVISION as D, ANALYST_BENCHMARK_OBSERVATIONS_FILE as E, normalizeAgentRxCategory as M, runAnalystBenchmark as N, codeTraceBenchCase as O, traceStoreEvidenceResolver as P, ANALYST_BENCHMARK_IMPLEMENTATION_FILES as S, ANALYST_BENCHMARK_MANIFEST_FILE as T, readAnalystBenchmarkArtifact as _, runInlineAnalystDefinition as a, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 as b, publicRlmAnalystDefinition as c, publicDirectAnalystDefinition as d, runChunkedAnalystDefinition as f, expandCodeTraceFailureBlocks as g, analystDefinitionProtocolSha256 as h, primeCodeTraceAnalystDefinition as i, agentRxPredictionsToFindings as j, codeTracerPredictionsToFindings as k, runReplVariableAnalystDefinition as l, analystDefinitionAsymmetries as m, createPrimeBenchmarkRunner as n, loadPublicBenchmarkRows as o, AnalystExpressivenessError as p, primeAnalystProtocolSha256 as r, createPublicBenchmarkRlmRunner as s, runAnalystBenchmarkCommand as t, createPublicBenchmarkDirectRunner as u, CODE_TRACE_BENCH_ANALYST_PROMPT as v, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE as w, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 as x, publicBenchmarkProtocolSha256 as y };
 
-//# sourceMappingURL=benchmark-command-xQK8nOI6.js.map
+//# sourceMappingURL=benchmark-command-BupdHRyf.js.map