@tangle-network/agent-eval 0.144.5 → 0.144.7

package/dist/{benchmark-command-CA_NFOmy.js → benchmark-command-BCafwNrf.js}

@@ -1,16 +1,17 @@
 import { c as ValidationError, t as AgentEvalError } from "./errors-D-LKuDhb.js";
 import { s as resolveModelPricing } from "./metrics-C9YY1OcL.js";
 import { a as CostLedgerPersistenceError, i as CostLedger, n as CostCallConflictError, o as CostReceiptCaptureError, r as CostCeilingReachedError, s as CostReservationExceededError, t as CostAccountingIncompleteError } from "./cost-ledger-DMFxsLKr.js";
-import { c as callLlmJson, r as LlmResponseError, t as LlmCallError } from "./llm-client-D3EoChAU.js";
-import { O as evidenceRefsFromRawFinding, h as TRACE_ANALYSIS_LIMITS, i as runTraceAnalyst } from "./kind-factory-BHIgPmzS.js";
+import { c as callLlmJson, r as LlmResponseError, t as LlmCallError } from "./llm-client-DzvMUsS_.js";
+import { D as RawAnalystFindingSchema, O as evidenceRefsFromRawFinding, T as RAW_FINDING_SCHEMA_PROMPT, h as TRACE_ANALYSIS_LIMITS, i as runTraceAnalyst } from "./kind-factory-BHIgPmzS.js";
 import { o as makeFinding, r as usageReceiptFromCostLedger } from "./usage-receipt-EVI8B8Xu.js";
 import { i as hashCanonical, r as canonicalString } from "./canonical-D011XM8r.js";
-import { M as resolveExternalOptimizerProcessLimits, f as runWithCleanup, n as createRunCostLedger, p as startExternalOptimizerModelProxy, r as fsCampaignStorage, t as acquireSingleRunLock } from "./single-run-lock-D5iN0Xzb.js";
-import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-19FQEMBK.js";
+import { D as resolveExternalOptimizerProcessLimits, f as runWithCleanup, n as createRunCostLedger, p as startExternalOptimizerModelProxy, r as fsCampaignStorage, t as acquireSingleRunLock } from "./single-run-lock-BMQEv1wG.js";
+import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-BiN49gK6.js";
 import { c as writeLedgerFileAtomically, s as withLedgerFileLock } from "./ledger-core-DXZIqu17.js";
 import { E as pairedBootstrap } from "./statistics-ByxzSiOM.js";
 import { i as otlpTextToTraceAnalysisStore, r as createOtlpBufferTraceStore, t as DEFAULT_MAX_TRACE_FILE_BYTES } from "./store-otlp-CKtTpRhv.js";
 import { i as summarizeAnalystBenchmarkRunner, n as runAnalystBenchmark, r as traceStoreEvidenceResolver } from "./benchmark-B181aMF9.js";
+import { c as primeProtocolSha256, d as runPrimeExchange, f as assertEqualDeclarativeTerms, n as buildPrimePrompt, t as analystUsageReceiptFromPrimeUsage, u as projectPrimeTrajectory } from "./prime-protocol-BfSalTfR.js";
 import { z } from "zod";
 import { constants, existsSync, lstatSync, readFileSync } from "node:fs";
 import * as nodePath from "node:path";
@@ -1207,7 +1208,7 @@ const ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES = Object.freeze([
 	"package.json",
 	"pnpm-lock.yaml"
 ]);
-const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "4785a1e0d785431f287362808dae777cf73125c551c18260117a711a5f2a6263";
+const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "96a42e1ad7cc0c9b00b2430ae09092c14bd5de385c696e849cb50507b9d77f02";
 /** The published benchmark evidence was produced at this package version, by
 * the retired one-shot direct runner, before trace analysts moved to the
 * recursive DSPy RLM engine. Both evidence digests below are historical facts
@@ -1252,8 +1253,10 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/analyst/benchmark-verification-artifacts.ts",
 	"src/analyst/benchmark-verification-outcome.ts",
 	"src/analyst/benchmark.ts",
+	"src/analyst/definition.ts",
 	"src/analyst/dspy-rlm-engine.ts",
 	"src/analyst/engine.ts",
+	"src/analyst/equal-terms.ts",
 	"src/analyst/exact-types.ts",
 	"src/analyst/finding-signature.ts",
 	"src/analyst/finding-subject.ts",
@@ -1261,6 +1264,7 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/analyst/parse-tolerant.ts",
 	"src/analyst/prime-bridge-transport.ts",
 	"src/analyst/prime-protocol.ts",
+	"src/analyst/reply-contract.ts",
 	"src/analyst/tool-groups.ts",
 	"src/analyst/trace-tool-callback.ts",
 	"src/analyst/types.ts",
@@ -1279,7 +1283,9 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/concurrency.ts",
 	"src/cost-ledger.ts",
 	"src/errors.ts",
+	"src/integrity/served-model.ts",
 	"src/judge-calibration.ts",
+	"src/judge-families.ts",
 	"src/ledger-core/atomic-file-lock.ts",
 	"src/ledger-core/canonical.ts",
 	"src/ledger-core/deep-freeze.ts",
@@ -1309,7 +1315,7 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/trace/raw-provider-sink.ts",
 	"src/verdict-cache.ts"
 ]);
-const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "46af7a98d6df73d845394827283390bac7a2fb9712f418b14b1093f19a21faea";
+const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "cc354effd79c8dfc8669c230706c67c63a06e3aff013f540806361263bae8860";
 function analystBenchmarkImplementationDigest() {
 	return ANALYST_BENCHMARK_IMPLEMENTATION_SHA256;
 }
@@ -2236,19 +2242,24 @@ Cite the block's first step and its last step as trace://<URL-encoded-trace-id>/
 Give the rationale as the concrete downstream evidence visible at the consequence step.
 Submit as soon as every candidate failure block has a supported verdict.
 Return no finding for a clean trajectory.`;
-/** One-shot JSON transport prompt for the direct runner. */
-function publicBenchmarkSystemPrompt(dataset) {
-	const fieldContract = dataset === "agentrx" ? AGENT_RX_JSON_CONTRACT : CODE_TRACE_JSON_CONTRACT;
-	return `${publicBenchmarkTaskPrompt(dataset)}
-
-${fieldContract}
-
-Return exactly one JSON object with:
+/** Reply-envelope contract shared by both one-shot datasets. */
+const PUBLIC_BENCHMARK_ENVELOPE_CONTRACT = `Return exactly one JSON object with:
 - "report": a concise evidence-based explanation, at most 4000 characters
 - "findings": the strict finding array
 Use an empty findings array when the trace does not support a finding.
 Do not return a bare array, markdown, trace URIs, copied excerpts, or fields not listed above.
 The runner constructs exact trace URIs and action previews from each selected step.`;
+/** Per-dataset field grammar for the one-shot JSON reply. */
+function publicBenchmarkFieldContract(dataset) {
+	return dataset === "agentrx" ? AGENT_RX_JSON_CONTRACT : CODE_TRACE_JSON_CONTRACT;
+}
+/** One-shot JSON transport prompt for the direct runner. */
+function publicBenchmarkSystemPrompt(dataset) {
+	return [
+		publicBenchmarkTaskPrompt(dataset),
+		publicBenchmarkFieldContract(dataset),
+		PUBLIC_BENCHMARK_ENVELOPE_CONTRACT
+	].join("\n\n");
 }
 /** Tool-loop prompt for the recursive runner. Same task, subject-encoded block. */
 function publicBenchmarkRlmInstructions(dataset) {
@@ -2256,6 +2267,7 @@ function publicBenchmarkRlmInstructions(dataset) {
 	return `${publicBenchmarkTaskPrompt(dataset)}
 ${outputContract}`;
 }
+/** Task text shared by every runner shape on one dataset. */
 function publicBenchmarkTaskPrompt(dataset) {
 	return dataset === "agentrx" ? AGENT_RX_PROMPT : CODE_TRACE_BENCH_ANALYST_PROMPT;
 }
@@ -3592,61 +3604,300 @@ function fileContext() {
 	};
 }
 //#endregion
+//#region src/analyst/definition.ts
+/**
+* AnalystDefinition — the declarative unit behind an analyst arm.
+*
+* An arm is one way of EXECUTING an analysis question: a one-shot JSON call, a
+* bridge-reached RLM, a recursive engine with trace tools. What the arm SAYS —
+* the question, the task text, the reply grammar, how evidence reaches the
+* model, the repair-turn and budget terms — is protocol, not execution, so it
+* lives here as one inspectable value. `bindAnalyst` (./bind) compiles a
+* definition plus a transport binding into a runnable arm, and the parity
+* suite holds the compiled arm to the byte against the arm's entry point, so a
+* definition cannot drift from what its arm actually sends.
+*
+* Three rules carried over from the repair-arm comparison contract
+* (trace-repair's `repairArmAsymmetries`), made structural here:
+*
+*   one contract    the reply grammar is a `ReplyContract` value on the
+*                   definition, never prose inside a runner body.
+*   one repair turn `analystDefinitionAsymmetries` refuses a set whose
+*                   definitions declare unequal repair turns, because a second
+*                   attempt is a second sample the other arms never got.
+*   declared difference what arms MAY differ in — the evidence projection, the
+*                   reasoning effort, the budget — is declared per definition
+*                   and rendered beside the comparison instead of being
+*                   inferred from two runners' source.
+*/
+/**
+* Thrown at bind time when a definition asks for something no strategy can
+* compile — an unknown projection × transport pair, a repair-turn count the
+* exchange machinery cannot grant, a reasoning effort the arm cannot map. The
+* message names the construct so an expressiveness gap is a loud, attributable
+* failure instead of a silently narrowed protocol.
+*/
+var AnalystExpressivenessError = class extends Error {};
+/**
+* Digest of everything a definition can send to its model. An inline
+* definition hashes under the historical prime-protocol domain, so its digest
+* equals the digest its bespoke arm always recorded; other projections hash
+* under the definition domain.
+*/
+function analystDefinitionProtocolSha256(definition) {
+	const { projection, replyContract } = definition;
+	if (projection.mode === "inline") return primeProtocolSha256({
+		question: definition.question,
+		...definition.taskDefinition === void 0 ? {} : { taskDefinition: definition.taskDefinition },
+		contractLines: replyContract.contractLines,
+		repairContractLines: replyContract.repairContractLines,
+		limits: {
+			...definition.contractLimits,
+			maxInlineTrajectoryChars: projection.maxInlineChars,
+			chunkedProjectionAttributeByteCap: projection.cappedAttributeBytes
+		}
+	});
+	return createHash("sha256").update(JSON.stringify({
+		kind: "analyst-definition-protocol",
+		mode: projection.mode,
+		question: definition.question,
+		taskDefinition: definition.taskDefinition ?? null,
+		contractLines: replyContract.contractLines,
+		repairContractLines: replyContract.repairContractLines,
+		limits: definition.contractLimits,
+		projection: projection.mode === "chunked" ? { attributeByteCaps: projection.attributeByteCaps } : { toolGroup: projection.toolGroup }
+	})).digest("hex");
+}
+/**
+* Refuse a set of definitions that cannot be compared on equal terms, and
+* render what still differs between the ones that can. The hard rule is the
+* repair turn: a malformed reply must earn the same number of retries in every
+* arm, because a retry is a second sample. Projection, reasoning effort, and
+* budget differences are declared and reported, never hidden.
+*/
+function analystDefinitionAsymmetries(definitions) {
+	const { ids, repairTurns } = assertEqualDeclarativeTerms("analyst definition", definitions.map((definition) => ({
+		id: definition.id,
+		repairTurns: definition.repair.turns
+	})));
+	const firstMode = definitions[0].projection.mode;
+	return {
+		ids,
+		repairTurns,
+		sharedProjectionMode: definitions.every((definition) => definition.projection.mode === firstMode) ? firstMode : null,
+		asymmetries: definitions.map((definition) => ({
+			id: definition.id,
+			projectionMode: definition.projection.mode,
+			reasoningEffort: definition.profile.model?.reasoningEffort ?? null,
+			timeoutMs: definition.budget.timeoutMs,
+			maxCostUsd: definition.budget.maxCostUsd ?? null,
+			maxOutputTokens: definition.budget.maxOutputTokens ?? null,
+			protocolSha256: definition.protocolSha256,
+			definitionSha256: analystDefinitionProtocolSha256(definition)
+		}))
+	};
+}
+//#endregion
+//#region src/analyst/reply-contract.ts
+/**
+* The reply grammar an analyst arm holds a model to, independent of transport.
+*
+* One contract serves every arm shape: the inline bridge protocol
+* (`runPrimeExchange`) reads the base fields, and one-shot JSON arms
+* additionally use the strict-envelope and all-rejected knobs. `PrimeReplyContract`
+* in ./prime-protocol is a type alias of this contract, so a consumer written
+* against the prime protocol names the same grammar object.
+*/
+/**
+* Decode a parsed reply value under a contract: strict envelope when declared,
+* then per-row decoding, then the all-rejected policy. Shape before count: a
+* malformed row never consumes an accepted slot.
+*/
+function decodeReplyRows(contract, value) {
+	let rawRows;
+	let extras = {};
+	if (contract.parseEnvelope) {
+		const envelope = contract.parseEnvelope(value);
+		rawRows = envelope.rows;
+		extras = envelope.extras;
+	} else {
+		const field = (typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0)?.[contract.rowsField];
+		if (!Array.isArray(field)) throw new ValidationError(`reply has no "${contract.rowsField}" array`);
+		rawRows = field;
+	}
+	const rows = [];
+	const rejected = [];
+	let overflow = 0;
+	rawRows.forEach((row, index) => {
+		const decoded = contract.decodeRow(row, index);
+		if (!decoded.ok) {
+			rejected.push({
+				index,
+				reason: decoded.reason
+			});
+			return;
+		}
+		if (contract.maxRows !== void 0 && rows.length >= contract.maxRows) {
+			overflow += 1;
+			return;
+		}
+		rows.push(decoded.row);
+	});
+	if (rows.length === 0 && rawRows.length > 0 && contract.whenAllRowsRejected === "fail") throw new ValidationError(`${contract.allRejectedMessage ?? "every reported row was malformed"}: ${rejected.map((entry) => entry.reason).join(" | ")}`);
+	return {
+		rows,
+		extras,
+		rejected,
+		reportedRows: rawRows.length,
+		overflow
+	};
+}
+//#endregion
 //#region src/analyst/benchmark-public-model.ts
-/** One-shot JSON baseline. This is not a recursive trace analyst. */
+/** 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) {
+	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");
+	if (definition.repair.turns !== 0) throw new AnalystExpressivenessError(`the one-shot JSON exchange grants no repair turn; definition '${definition.id}' declares ${definition.repair.turns}`);
+	const reasoningEffort = definition.profile.model?.reasoningEffort;
+	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`);
 	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");
 	if (typeof config.recordExecution !== "function") throw new TypeError("recordExecution must be a function");
 	const maxOutputTokens = positiveSafeInteger(config.maxOutputTokens, "maxOutputTokens");
 	const timeoutMs = positiveSafeInteger(config.timeoutMs, "timeoutMs");
+	const maxCostUsd = config.maxCostUsdPerAnalysis ?? 1;
+	assertDeclaredBudget(definition, {
+		timeoutMs,
+		maxOutputTokens,
+		maxCostUsd
+	});
 	const maxReasoningTokens = config.maxReasoningTokens ?? maxOutputTokens * 4;
 	const maxModelRequestBytes = config.maxModelRequestBytes ?? 16 * 1024 * 1024;
 	const maxModelResponseBytes = config.maxModelResponseBytes ?? 4 * 1024 * 1024;
 	const modelRequestTimeoutMs = config.modelRequestTimeoutMs ?? timeoutMs;
 	const pricing = config.pricing ?? pricingForModel$2(model);
-	const maxCostUsd = config.maxCostUsdPerAnalysis ?? 1;
 	const costLedger = config.costLedger ?? new CostLedger();
 	const durability = config.durability ? {
 		runIdentitySha256: requiredString(config.durability.runIdentitySha256, "durability.runIdentitySha256"),
 		responseCacheDir: requiredString(config.durability.responseCacheDir, "durability.responseCacheDir")
 	} : void 0;
-	const actor = dataset === "agentrx" ? "agentrx-root-cause-localizer" : "codetracebench-step-localizer";
-	const outputAdapter = dataset === "agentrx" ? "agentrx-taxonomy-and-root-step" : "codetracebench-incorrect-block";
+	const systemPrompt = [definition.taskDefinition, ...replyContract.contractLines].join("\n\n");
 	return {
-		id: "direct",
+		id: definition.id,
 		async analyze(input, context) {
-			const trajectoryId = trajectoryIdFromCaseId$2(dataset, context.caseId);
+			const trajectoryId = binding.subjectFromCaseId(context.caseId);
 			const costTags = {
-				analystId: actor,
+				analystId: binding.costActor,
 				benchmarkCaseId: context.caseId,
 				benchmarkRepetition: String(context.repetition)
 			};
 			let rawPredictions = [];
-			let rejectedBlocks = [];
+			let rejectedRows = [];
 			let modelFindings = [];
 			let providerModel = model;
 			let producedAt;
 			let modelMetadata = {
-				analysisMode: "direct-baseline",
-				outputAdapter,
-				protocolSha256: publicBenchmarkProtocolSha256(dataset),
+				...binding.baseMetadata,
+				protocolSha256: definition.protocolSha256,
 				callRef
 			};
 			try {
-				if (!input.traceStore) throw new Error(`${dataset} model runner requires a trace store`);
-				const preparedContext = await prepareSingleTraceContext(input.traceStore, context);
-				if (preparedContext === void 0) throw new Error(`${dataset} trace '${trajectoryId}' has no readable spans`);
+				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: publicBenchmarkSystemPrompt(dataset)
+						content: systemPrompt
 					}, {
 						role: "user",
-						content: `TRACE DATA:\n${preparedContext}\n\nReturn the analysis JSON object.`
+						content: binding.userMessage(preparedContext)
 					}],
 					jsonMode: true,
 					thinking: "disabled",
@@ -3676,14 +3927,14 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 						error: cached.error,
 						metadata: modelMetadata
 					};
-					const response = parsePublicBenchmarkModelResponse(dataset, cached.response);
-					rawPredictions = response.findings;
-					rejectedBlocks = response.rejectedBlocks;
+					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,
-						report: response.report,
+						...response.extras,
 						providerModel: cached.metadata.providerModel,
 						providerDurationMs: cached.metadata.providerDurationMs,
 						finishReason: cached.metadata.finishReason
@@ -3712,8 +3963,8 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 								},
 								costLedger,
 								channel: "analyst",
-								phase: "analyst.public-benchmark",
-								actor,
+								phase: binding.costPhase,
+								actor: binding.costActor,
 								tags: costTags,
 								callId: providerCallId,
 								...context.signal ? { signal: context.signal } : {}
@@ -3732,7 +3983,7 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 									...context.signal ? { signal: context.signal } : {},
 									idempotencyKey: providerCallId
 								});
-								const response = parsePublicBenchmarkModelResponse(dataset, completed.value);
+								const response = decodeReplyRows(replyContract, completed.value);
 								const responseProducedAt = (/* @__PURE__ */ new Date()).toISOString();
 								const receipt = requiredSettledReceipt(costLedger, providerCallId);
 								if (cacheIdentity) writePublicBenchmarkResponseCache(durability.responseCacheDir, {
@@ -3778,26 +4029,25 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 						}
 					});
 					const response = completed.response;
-					rawPredictions = response.findings;
-					rejectedBlocks = response.rejectedBlocks;
+					rawPredictions = response.rows;
+					rejectedRows = response.rejected.map((entry) => entry.reason);
 					providerModel = completed.result.model;
 					producedAt = completed.producedAt;
 					modelMetadata = {
 						...modelMetadata,
 						responseSource: "provider",
-						report: response.report,
+						...response.extras,
 						providerModel: completed.result.model,
 						providerDurationMs: completed.result.durationMs,
 						finishReason: completed.result.finishReason ?? null,
 						cost: costReceiptMetadata(completed.receipt)
 					};
 				}
-				const converted = await publicBenchmarkPredictionsToFindings({
-					dataset,
-					trajectoryId,
-					predictions: rawPredictions,
+				const converted = await binding.expandRows({
+					subject: trajectoryId,
+					rows: rawPredictions,
 					store: input.traceStore,
-					analystId: "direct",
+					analystId: definition.id,
 					providerModel,
 					producedAt: requiredString(producedAt ?? "", "finding producedAt"),
 					...context.signal ? { signal: context.signal } : {}
@@ -3807,11 +4057,11 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 					...modelMetadata,
 					blockDiagnostics: {
 						...converted.diagnostics,
-						rejectedBlocks
+						rejectedBlocks: rejectedRows
 					}
 				};
-				if (dataset === "codetracebench") await validateCodeTraceFindingEvidence({
-					trajectoryId,
+				if (binding.verifyFindings) await binding.verifyFindings({
+					subject: trajectoryId,
 					findings: modelFindings,
 					store: input.traceStore,
 					...context.signal ? { signal: context.signal } : {}
@@ -3844,6 +4094,11 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 		}
 	};
 }
+/** A definition that declares one budget while the transport runs another is refused. */
+function assertDeclaredBudget(definition, effective) {
+	const declared = definition.budget;
+	if (declared.timeoutMs !== effective.timeoutMs || declared.maxOutputTokens !== effective.maxOutputTokens || declared.maxCostUsd !== effective.maxCostUsd) throw new AnalystExpressivenessError(`definition '${definition.id}' declares budget ${JSON.stringify(declared)} but the bound transport runs ${JSON.stringify(effective)}; the declaration must state what executes`);
+}
 function settleCachedResponse(costLedger, cached) {
 	const settled = costLedger.list().find((receipt) => receipt.callId === cached.callId);
 	const pending = costLedger.listPending?.().find((record) => record.callId === cached.callId);
@@ -4001,27 +4256,56 @@ const AgentRxModelResponseSchema = z.object({
 	report: z.string().min(1).max(4e3),
 	findings: z.array(AgentRxPredictionSchema.extend({ category: AgentRxCategorySchema }).strict()).max(1)
 }).strict();
-function parsePublicBenchmarkModelResponse(dataset, value) {
+/**
+* The one-shot reply grammar per dataset. The envelope is the contract and
+* stays strict. Individual CodeTraceBench blocks are model output: one
+* malformed block must not void a case whose remaining blocks are usable and
+* whose provider call is already paid for, so rows decode individually and
+* every rejection is reported.
+*/
+function directReplyContract(dataset) {
 	if (dataset === "agentrx") return {
-		...AgentRxModelResponseSchema.parse(value),
-		rejectedBlocks: []
-	};
-	const envelope = CodeTraceModelResponseEnvelopeSchema.parse(value);
-	const findings = [];
-	const rejectedBlocks = [];
-	for (const [index, block] of envelope.findings.entries()) {
-		const parsed = CodeTraceBlockPredictionSchema.safeParse(block);
-		if (parsed.success) {
-			findings.push(parsed.data);
-			continue;
+		rowsField: "findings",
+		contractLines: [publicBenchmarkFieldContract("agentrx"), PUBLIC_BENCHMARK_ENVELOPE_CONTRACT],
+		repairContractLines: [],
+		parseEnvelope(value) {
+			const parsed = AgentRxModelResponseSchema.parse(value);
+			return {
+				rows: parsed.findings,
+				extras: { report: parsed.report }
+			};
+		},
+		decodeRow(row) {
+			return {
+				ok: true,
+				row
+			};
 		}
-		rejectedBlocks.push(`block ${index}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`);
-	}
-	if (findings.length === 0 && envelope.findings.length > 0) throw new ValidationError(`every reported failure block was malformed: ${rejectedBlocks.join(" | ")}`);
+	};
 	return {
-		report: envelope.report,
-		findings,
-		rejectedBlocks
+		rowsField: "findings",
+		contractLines: [publicBenchmarkFieldContract("codetracebench"), PUBLIC_BENCHMARK_ENVELOPE_CONTRACT],
+		repairContractLines: [],
+		parseEnvelope(value) {
+			const envelope = CodeTraceModelResponseEnvelopeSchema.parse(value);
+			return {
+				rows: envelope.findings,
+				extras: { report: envelope.report }
+			};
+		},
+		decodeRow(row, index) {
+			const parsed = CodeTraceBlockPredictionSchema.safeParse(row);
+			if (parsed.success) return {
+				ok: true,
+				row: parsed.data
+			};
+			return {
+				ok: false,
+				reason: `block ${index}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`
+			};
+		},
+		whenAllRowsRejected: "fail",
+		allRejectedMessage: "every reported failure block was malformed"
 	};
 }
 async function publicBenchmarkPredictionsToFindings(options) {
@@ -4088,12 +4372,12 @@ async function publicBenchmarkPredictionsToFindings(options) {
 		...options.signal ? { signal: options.signal } : {}
 	});
 }
-async function prepareSingleTraceContext(store, context) {
+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 TRACE_PROJECTION_ATTRIBUTE_BYTE_CAPS) {
+	for (const perAttributeByteCap of attributeByteCaps) {
 		const viewed = await store.viewTrace({
 			trace_id: traceId,
 			per_attribute_byte_cap: perAttributeByteCap
@@ -4243,18 +4527,156 @@ function contiguousSegments(sortedSteps) {
 }
 //#endregion
 //#region src/analyst/benchmark-public-rlm.ts
-/** Public benchmark candidate that runs the actual recursive trace analyst. */
+/** The dspy-rlm arm as a declarative unit for one public dataset. */
+function publicRlmAnalystDefinition(dataset, args) {
+	return {
+		id: "dspy-rlm",
+		description: dataset === "agentrx" ? "Localizes the first unrecoverable root-cause step." : "Localizes every incorrect state-changing assistant step.",
+		version: "1.0.0",
+		area: dataset === "agentrx" ? "root-cause" : "incorrect",
+		profile: {},
+		question: dataset === "agentrx" ? "What is the first unrecoverable root cause in this failed trajectory?" : "Which assistant steps are incorrect under the CodeTraceBench definition?",
+		taskDefinition: args.instructions,
+		projection: {
+			mode: "repl-variable",
+			toolGroup: "singleTrace"
+		},
+		replyContract: {
+			rowsField: "findings",
+			contractLines: [RAW_FINDING_SCHEMA_PROMPT],
+			repairContractLines: [],
+			decodeRow(row) {
+				const parsed = RawAnalystFindingSchema.safeParse(row);
+				if (parsed.success) return {
+					ok: true,
+					row: parsed.data
+				};
+				return {
+					ok: false,
+					reason: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
+				};
+			}
+		},
+		contractLimits: {
+			maxIterations: args.engineLimits.maxIterations,
+			maxLlmCalls: args.engineLimits.maxLlmCalls,
+			maxToolCalls: args.engineLimits.maxToolCalls,
+			maxOutputChars: args.engineLimits.maxOutputChars
+		},
+		budget: {
+			timeoutMs: args.timeoutMs,
+			maxCostUsd: args.maxCostUsd,
+			maxOutputTokens: args.maxOutputTokens,
+			engineLimits: args.engineLimits
+		},
+		repair: { turns: 1 },
+		protocolSha256: args.protocolSha256,
+		binding: {
+			kind: "repl-variable",
+			traceAnalystId: dataset === "agentrx" ? "agentrx-dspy-rlm" : "codetracebench-dspy-rlm",
+			subjectFromCaseId: (caseId) => trajectoryIdFromCaseId$1(dataset, caseId),
+			baseMetadata: {
+				analysisMode: "recursive",
+				engine: "dspy-rlm"
+			},
+			findingBaseMetadata: {
+				analysis_mode: "recursive",
+				engine: "dspy-rlm"
+			},
+			costPhase: "analyst.public-benchmark.dspy-rlm",
+			...dataset === "codetracebench" ? { metadataFromSubject: codeTraceBlockMetadataFromSubject } : {},
+			async adapt({ subject, findings, analystId, store, signal }) {
+				return adaptPublicBenchmarkFindings({
+					dataset,
+					trajectoryId: subject,
+					findings: [...findings],
+					analystId,
+					store,
+					...signal ? { signal } : {}
+				});
+			},
+			...dataset === "codetracebench" ? { consensus: codeTraceConsensusPort() } : {},
+			abstentionFallback: (fallbackConfig) => createPublicBenchmarkDirectRunner(dataset, fallbackConfig)
+		}
+	};
+}
+/** Step-level majority consensus on the CodeTraceBench block grammar. */
+function codeTraceConsensusPort() {
+	return {
+		vote(samples) {
+			const consensus = consensusCodeTraceBlocks(samples.map((sample) => [...sample]));
+			return {
+				blocks: consensus.blocks,
+				decision: consensus.decision
+			};
+		},
+		async expand({ subject, blocks, store, analystId, producedAt, signal }) {
+			const expanded = await expandCodeTraceFailureBlocks({
+				trajectoryId: subject,
+				blocks,
+				store,
+				analystId,
+				producedAt,
+				...signal ? { signal } : {}
+			});
+			return {
+				findings: expanded.findings,
+				diagnostics: expanded.diagnostics
+			};
+		},
+		sampleRecord(assignments) {
+			return {
+				blocks: sampleBlockRecords(assignments),
+				steps: assignments.map((assignment) => assignment.step)
+			};
+		}
+	};
+}
+/** Thin shell: validate config, declare the definition, run the repl-variable strategy. */
 function createPublicBenchmarkRlmRunner(dataset, 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 && dataset !== "codetracebench") throw new Error("dspyRlm.samples > 1 requires the codetracebench dataset; step-level consensus is defined on its block grammar");
-	const limits = {
+	return runReplVariableAnalystDefinition(publicRlmAnalystDefinition(dataset, {
+		instructions: config.instructionsOverride?.text ?? publicBenchmarkRlmInstructions(dataset),
+		protocolSha256: effectiveAnalystProtocolSha256(dataset, config.instructionsOverride),
+		timeoutMs: config.timeoutMs,
+		maxOutputTokens: config.maxOutputTokens,
+		maxCostUsd: config.maxCostUsdPerAnalysis ?? 1,
+		engineLimits: rlmEngineLimits(config)
+	}), config);
+}
+/** Engine iteration limits with this arm's defaults applied. */
+function rlmEngineLimits(config) {
+	return {
 		maxIterations: config.dspyRlm?.maxIterations ?? 14,
 		maxLlmCalls: config.dspyRlm?.maxLlmCalls ?? 8,
 		maxToolCalls: config.dspyRlm?.maxToolCalls ?? 80,
 		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) {
+	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;
+	if (instructions === void 0) throw new AnalystExpressivenessError(`the repl-variable strategy runs the definition's task text as engine instructions; definition '${definition.id}' declares none`);
+	if (config.instructionsOverride !== void 0 && config.instructionsOverride.text !== instructions) throw new AnalystExpressivenessError(`definition '${definition.id}' declares instructions that differ from the transport's instructionsOverride; one text must execute`);
+	const area = definition.area;
+	if (area === void 0) throw new AnalystExpressivenessError(`the repl-variable strategy stamps the definition's area on every finding; definition '${definition.id}' declares none`);
+	const limits = definition.budget.engineLimits;
+	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({
 		call: config.call,
@@ -4277,18 +4699,26 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 		...config.dspyRlm?.traceToolTimeoutMs === void 0 ? {} : { traceToolTimeoutMs: config.dspyRlm.traceToolTimeoutMs },
 		...config.dspyRlm?.runner ? { runner: config.dspyRlm.runner } : {}
 	});
-	const instructions = config.instructionsOverride?.text ?? publicBenchmarkRlmInstructions(dataset);
-	const protocolSha256 = effectiveAnalystProtocolSha256(dataset, config.instructionsOverride);
-	const definition = publicBenchmarkDefinition(dataset, limits, instructions);
+	const protocolSha256 = definition.protocolSha256;
+	const traceDefinition = {
+		id: binding.traceAnalystId,
+		description: definition.description,
+		area,
+		version: definition.version,
+		question: definition.question,
+		instructions,
+		toolGroup: projection.toolGroup,
+		limits
+	};
 	const { instructionsOverride: _rlmOnlyOverride, ...directConfig } = config;
-	const abstentionFallbackRunner = createPublicBenchmarkDirectRunner(dataset, {
+	const abstentionFallbackRunner = binding.abstentionFallback({
 		...directConfig,
 		costLedger
 	});
 	return {
-		id: "dspy-rlm",
+		id: definition.id,
 		async analyze(input, context) {
-			const trajectoryId = trajectoryIdFromCaseId$1(dataset, context.caseId);
+			const trajectoryId = binding.subjectFromCaseId(context.caseId);
 			const tags = {
 				benchmarkCaseId: context.caseId,
 				benchmarkRepetition: String(context.repetition)
@@ -4296,7 +4726,7 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 			let usage;
 			let rawFindings = [];
 			try {
-				if (!input.traceStore) throw new Error(`${dataset} DSPy RLM runner requires a trace store`);
+				if (!input.traceStore) throw new Error(`repl-variable analyst '${definition.id}' requires a trace store`);
 				if (samples > 1) {
 					const store = input.traceStore;
 					const caseUsageFilter = {
@@ -4310,14 +4740,14 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 					for (let sample = 0; sample < samples; sample += 1) {
 						let sampleUsage;
 						const completed = await runTraceAnalyst({
-							definition,
+							definition: traceDefinition,
 							engine,
 							store,
 							context: {
 								runId: context.caseId,
 								correlationId: `${context.caseId}:${context.repetition}:sample-${sample}`,
 								costLedger,
-								costPhase: "analyst.public-benchmark.dspy-rlm",
+								costPhase: binding.costPhase,
 								tags,
 								recordUsage: (receipt) => {
 									sampleUsage = receipt;
@@ -4328,8 +4758,8 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 						});
 						const producedAt = (/* @__PURE__ */ new Date()).toISOString();
 						const sampleFindings = completed.findings.map((finding) => makeFinding({
-							analyst_id: "dspy-rlm",
-							area: "incorrect",
+							analyst_id: definition.id,
+							area,
 							subject: finding.subject,
 							claim: finding.claim,
 							rationale: finding.rationale,
@@ -4338,20 +4768,18 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 							evidence_refs: evidenceRefsFromRawFinding(finding),
 							recommended_action: finding.recommended_action,
 							metadata: {
-								analysis_mode: "recursive",
-								engine: "dspy-rlm",
+								...binding.findingBaseMetadata,
 								model: config.model,
 								sample,
-								...codeTraceBlockMetadataFromSubject(finding.subject) ?? {}
+								...binding.metadataFromSubject?.(finding.subject) ?? {}
 							},
 							produced_at: producedAt
 						}));
 						rawFindings = [...rawFindings, ...sampleFindings];
-						const adapted = await adaptPublicBenchmarkFindings({
-							dataset,
-							trajectoryId,
+						const adapted = await binding.adapt({
+							subject: trajectoryId,
 							findings: sampleFindings,
-							analystId: "dspy-rlm",
+							analystId: definition.id,
 							store,
 							...context.signal ? { signal: context.signal } : {}
 						});
@@ -4366,18 +4794,17 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 							modelCalls: completed.modelCalls,
 							toolCalls: completed.toolCalls,
 							runtime: completed.runtime,
-							blocks: sampleBlockRecords(assignments),
-							steps: assignments.map((assignment) => assignment.step),
+							...binding.consensus.sampleRecord(assignments),
 							...adapted.diagnostics ? { blockDiagnostics: adapted.diagnostics } : {},
 							...sampleUsage ? { usage: sampleUsage } : {}
 						});
 					}
-					const consensus = consensusCodeTraceBlocks(sampleAssignments);
-					const expanded = await expandCodeTraceFailureBlocks({
-						trajectoryId,
+					const consensus = binding.consensus.vote(sampleAssignments);
+					const expanded = await binding.consensus.expand({
+						subject: trajectoryId,
 						blocks: consensus.blocks,
 						store,
-						analystId: "dspy-rlm",
+						analystId: definition.id,
 						producedAt: (/* @__PURE__ */ new Date()).toISOString(),
 						...context.signal ? { signal: context.signal } : {}
 					});
@@ -4388,8 +4815,7 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 						findings: fallback && !fallback.error ? fallback.findings : expanded.findings,
 						usage,
 						metadata: {
-							analysisMode: "recursive",
-							engine: "dspy-rlm",
+							...binding.baseMetadata,
 							protocolSha256,
 							samples,
 							sampleRuns,
@@ -4406,14 +4832,14 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 					};
 				}
 				const completed = await runTraceAnalyst({
-					definition,
+					definition: traceDefinition,
 					engine,
 					store: input.traceStore,
 					context: {
 						runId: context.caseId,
 						correlationId: `${context.caseId}:${context.repetition}`,
 						costLedger,
-						costPhase: "analyst.public-benchmark.dspy-rlm",
+						costPhase: binding.costPhase,
 						tags,
 						recordUsage: (receipt) => {
 							usage = receipt;
@@ -4423,8 +4849,8 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 				});
 				const producedAt = (/* @__PURE__ */ new Date()).toISOString();
 				rawFindings = completed.findings.map((finding) => makeFinding({
-					analyst_id: "dspy-rlm",
-					area: dataset === "agentrx" ? "root-cause" : "incorrect",
+					analyst_id: definition.id,
+					area,
 					subject: finding.subject,
 					claim: finding.claim,
 					rationale: finding.rationale,
@@ -4433,18 +4859,16 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 					evidence_refs: evidenceRefsFromRawFinding(finding),
 					recommended_action: finding.recommended_action,
 					metadata: {
-						analysis_mode: "recursive",
-						engine: "dspy-rlm",
+						...binding.findingBaseMetadata,
 						model: config.model,
-						...dataset === "codetracebench" ? codeTraceBlockMetadataFromSubject(finding.subject) : {}
+						...binding.metadataFromSubject?.(finding.subject) ?? {}
 					},
 					produced_at: producedAt
 				}));
-				const adapted = await adaptPublicBenchmarkFindings({
-					dataset,
-					trajectoryId,
+				const adapted = await binding.adapt({
+					subject: trajectoryId,
 					findings: rawFindings,
-					analystId: "dspy-rlm",
+					analystId: definition.id,
 					store: input.traceStore,
 					...context.signal ? { signal: context.signal } : {}
 				});
@@ -4463,8 +4887,7 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 					findings: fallback && !fallback.error ? fallback.findings : adapted.findings,
 					usage,
 					metadata: {
-						analysisMode: "recursive",
-						engine: "dspy-rlm",
+						...binding.baseMetadata,
 						protocolSha256,
 						...adapted.diagnostics ? { blockDiagnostics: adapted.diagnostics } : {},
 						answer: completed.answer,
@@ -4487,8 +4910,7 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 					usage,
 					error: publicBenchmarkError(error, []),
 					metadata: {
-						analysisMode: "recursive",
-						engine: "dspy-rlm",
+						...binding.baseMetadata,
 						...samples > 1 ? { samples } : {},
 						rawFindings
 					}
@@ -4516,18 +4938,6 @@ function sampleBlockRecords(assignments) {
 		acceptedSteps
 	}));
 }
-function publicBenchmarkDefinition(dataset, limits, instructions) {
-	return {
-		id: dataset === "agentrx" ? "agentrx-dspy-rlm" : "codetracebench-dspy-rlm",
-		description: dataset === "agentrx" ? "Localizes the first unrecoverable root-cause step." : "Localizes every incorrect state-changing assistant step.",
-		area: dataset === "agentrx" ? "root-cause" : "incorrect",
-		version: "1.0.0",
-		question: dataset === "agentrx" ? "What is the first unrecoverable root cause in this failed trajectory?" : "Which assistant steps are incorrect under the CodeTraceBench definition?",
-		instructions,
-		toolGroup: "singleTrace",
-		limits
-	};
-}
 function pricingForModel$1(model) {
 	const pricing = resolveModelPricing(model);
 	if (!pricing) throw new Error(`no pricing is configured for '${model}'; provide PublicAnalystBenchmarkModelConfig.pricing`);
@@ -4891,455 +5301,31 @@ function nodeHttpPrimeBridgeTransport() {
 	};
 }
 //#endregion
-//#region src/analyst/prime-protocol.ts
-function buildPrimePrompt(spec) {
-	return [
-		`QUESTION: ${spec.question}`,
-		"",
-		...spec.taskDefinition === void 0 ? [] : [
-			"TASK DEFINITION:",
-			spec.taskDefinition,
-			""
-		],
-		...spec.contractLines,
-		"",
-		spec.trajectoryHeader,
-		spec.renderedTrajectory,
-		...spec.trailer === void 0 ? [] : ["", spec.trailer]
-	].join("\n");
-}
-/** Carries the malformed reply and the contract — never the trajectory. */
-function buildPrimeRepairPrompt(spec) {
-	return [
-		"Your previous reply to a trace-analysis task was structurally malformed and could not be parsed",
-		`(${spec.defect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON — one`,
-		"fenced ```json block, no other text, no tools. The JSON object has exactly two fields:",
-		...spec.repairContractLines,
-		"",
-		"PREVIOUS REPLY:",
-		spec.previousReply
-	].join("\n");
-}
-/**
-* Recover the reply's JSON object.
-*
-* Distinct from `extractJsonPayload` in ../llm-client, which serves a response
-* that DECLARES a JSON root and therefore must not scan onward. A prime reply
-* is prose plus a fenced block, and when the model emits several fences the
-* last one is its answer — so fences are scanned in reverse, and only then is a
-* brace-to-brace slice tried.
-*/
-function extractPrimeJsonObject(text) {
-	const direct = parsePrimeJsonObject(text);
-	if (direct) return direct;
-	const fenced = [...text.matchAll(/```(?:json)?\s*\n?([\s\S]*?)```/g)];
-	for (let index = fenced.length - 1; index >= 0; index -= 1) {
-		const candidate = parsePrimeJsonObject(fenced[index][1]);
-		if (candidate) return candidate;
-	}
-	const start = text.indexOf("{");
-	const end = text.lastIndexOf("}");
-	if (start >= 0 && end > start) {
-		const candidate = parsePrimeJsonObject(text.slice(start, end + 1));
-		if (candidate) return candidate;
-	}
-	return null;
-}
-/** Why the reply cannot be read as a prime answer, or null when it can. */
-function primeReplyDefect(parsed, rowsField) {
-	if (parsed === null) return "no parseable JSON object";
-	if (!Array.isArray(parsed[rowsField])) return `JSON has no "${rowsField}" array`;
-	return null;
-}
-function parsePrimeJsonObject(text) {
-	try {
-		const value = JSON.parse(text.trim());
-		return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-	} catch {
-		return null;
-	}
-}
-function emptyPrimeRawUsage() {
-	return {
-		calls: null,
-		inputTokens: null,
-		outputTokens: null,
-		bridgeEstimated: false
-	};
-}
-/** Read the bridge's OpenAI-shaped `usage` object. */
-function normalizePrimeUsage(raw) {
-	if (typeof raw !== "object" || raw === null) return emptyPrimeRawUsage();
-	const record = raw;
-	return {
-		calls: tokenCountOrNull(record.model_requests),
-		inputTokens: tokenCountOrNull(record.prompt_tokens),
-		outputTokens: tokenCountOrNull(record.completion_tokens),
-		bridgeEstimated: record.estimated === true
-	};
-}
-/**
-* Sum two turns. Each side poisons independently: two turns that both report
-* input and neither report output yield a real input total beside a null
-* output, because discarding a measured count is as wrong as inventing one.
-*/
-function mergePrimeRawUsage(a, b) {
-	return {
-		calls: sumOrNull(a.calls, b.calls),
-		inputTokens: sumOrNull(a.inputTokens, b.inputTokens),
-		outputTokens: sumOrNull(a.outputTokens, b.outputTokens),
-		bridgeEstimated: a.bridgeEstimated || b.bridgeEstimated
-	};
-}
-function sumOrNull(a, b) {
-	return a !== null && b !== null ? a + b : null;
-}
-function tokenCountOrNull(value) {
-	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
-}
-/**
-* Bind raw prime usage to agent-eval's typed receipt.
-*
-* `RunTokenUsage.input` and `.output` are non-nullable, so a one-sided count
-* cannot round-trip through `tokens` without writing a zero nobody measured.
-* The complete-accounting field therefore stays null, the reported side is
-* carried verbatim in `partialTokens`, and its price becomes the receipt's
-* `knownCostUsd` lower bound.
-*
-* Only agent-eval calls this; consumers with no pricing table read
-* `PrimeRawUsage` directly.
-*/
-function analystUsageReceiptFromPrimeUsage(usage, pricing) {
-	const { calls, inputTokens, outputTokens, bridgeEstimated } = usage;
-	const estimatedTokens = bridgeEstimated ? { tokensEstimated: true } : {};
-	if (inputTokens !== null && outputTokens !== null) return {
-		calls,
-		tokens: {
-			input: inputTokens,
-			output: outputTokens
-		},
-		cost: {
-			kind: "estimated",
-			usd: priceTokens(inputTokens, outputTokens, pricing)
-		},
-		...estimatedTokens
-	};
-	if (inputTokens === null && outputTokens === null) return {
-		calls,
-		tokens: null,
-		cost: {
-			kind: "uncaptured",
-			usd: null
-		},
-		...estimatedTokens
-	};
-	return {
-		calls,
-		tokens: null,
-		partialTokens: {
-			input: inputTokens,
-			output: outputTokens
-		},
-		cost: {
-			kind: "uncaptured",
-			usd: null
-		},
-		knownCostUsd: priceTokens(inputTokens ?? 0, outputTokens ?? 0, pricing),
-		...estimatedTokens
-	};
-}
-function priceTokens(input, output, pricing) {
-	return (input * pricing.inputUsdPerMillion + output * pricing.outputUsdPerMillion) / 1e6;
-}
-/**
-* Run the protocol: one call, one bounded repair turn on a structurally
-* malformed reply, then decode. Zero valid rows from a well-formed reply is an
-* honest null, not a failure.
-*/
-async function runPrimeExchange(options) {
-	const { contract } = options;
-	const turns = [];
-	const repair = {
-		attempted: false,
-		succeeded: null
-	};
-	const first = await callPrimeTurn(options, options.prompt);
-	if (!first.ok) return {
-		ok: false,
-		failure: first.failure,
-		usage: mergeTurns(turns),
-		turns,
-		repair
-	};
-	turns.push({
-		turn: "first",
-		usage: first.usage,
-		rawUsage: first.rawUsage
-	});
-	let reply = first.content;
-	let parsed = extractPrimeJsonObject(reply);
-	let defect = primeReplyDefect(parsed, contract.rowsField);
-	if (defect !== null && options.repair) {
-		repair.attempted = true;
-		const second = await callPrimeTurn(options, buildPrimeRepairPrompt({
-			defect,
-			previousReply: reply,
-			repairContractLines: contract.repairContractLines
-		}));
-		if (!second.ok) return {
-			ok: false,
-			failure: second.failure,
-			usage: mergeTurns(turns),
-			turns,
-			repair,
-			reply
-		};
-		turns.push({
-			turn: "repair",
-			usage: second.usage,
-			rawUsage: second.rawUsage
-		});
-		reply = second.content;
-		parsed = extractPrimeJsonObject(reply);
-		defect = primeReplyDefect(parsed, contract.rowsField);
-		repair.succeeded = defect === null;
-	}
-	const usage = mergeTurns(turns);
-	if (defect !== null) return {
-		ok: false,
-		failure: {
-			kind: "malformed-reply",
-			message: `${defect} in prime reply${repair.attempted ? " even after the bounded repair turn" : ""}`
-		},
-		usage,
-		turns,
-		repair,
-		reply
-	};
-	const rawRows = parsed[contract.rowsField];
-	const rows = [];
-	const rejected = [];
-	let overflow = 0;
-	rawRows.forEach((row, index) => {
-		const decoded = contract.decodeRow(row, index);
-		if (!decoded.ok) {
-			rejected.push({
-				index,
-				reason: decoded.reason
-			});
-			return;
-		}
-		if (contract.maxRows !== void 0 && rows.length >= contract.maxRows) {
-			overflow += 1;
-			return;
-		}
-		rows.push(decoded.row);
-	});
-	const answer = parsed.answer;
-	return {
-		ok: true,
-		answer: typeof answer === "string" ? answer : null,
-		rows,
-		rejected,
-		reportedRows: rawRows.length,
-		overflow,
-		usage,
-		turns,
-		repair,
-		reply
-	};
-}
-async function callPrimeTurn(options, content) {
-	const { transport, url, model, timeoutMs, signal } = options;
-	const controller = new AbortController();
-	const forwardAbort = () => controller.abort(signal?.reason);
-	if (signal?.aborted) controller.abort(signal.reason);
-	else signal?.addEventListener("abort", forwardAbort, { once: true });
-	const deadline = setTimeout(() => controller.abort(), timeoutMs);
-	let result;
-	try {
-		result = await transport({
-			url,
-			body: {
-				model,
-				messages: [{
-					role: "user",
-					content
-				}]
-			},
-			signal: controller.signal
-		});
-	} catch (error) {
-		if (signal?.aborted) return {
-			ok: false,
-			failure: {
-				kind: "aborted",
-				message: "prime exchange cancelled by the caller",
-				cause: error
-			}
-		};
-		if (controller.signal.aborted) return {
-			ok: false,
-			failure: {
-				kind: "deadline",
-				message: `bridge call exceeded ${timeoutMs}ms`
-			}
-		};
-		return {
-			ok: false,
-			failure: {
-				kind: "transport",
-				message: `bridge transport failure: ${error instanceof Error ? error.message : String(error)}`
-			}
-		};
-	} finally {
-		clearTimeout(deadline);
-		signal?.removeEventListener("abort", forwardAbort);
-	}
-	if (result.status !== 200) {
-		const bodySnippet = result.text.slice(0, 500);
-		return {
-			ok: false,
-			failure: {
-				kind: "http-status",
-				message: `bridge HTTP ${result.status}: ${bodySnippet}`,
-				status: result.status,
-				bodySnippet
-			}
-		};
-	}
-	let response;
-	try {
-		response = JSON.parse(result.text);
-	} catch {
-		return {
-			ok: false,
-			failure: {
-				kind: "unparseable-json",
-				message: `bridge returned unparseable JSON (${result.text.length} bytes)`
-			}
-		};
-	}
-	const replyContent = primeReplyContent(response);
-	if (replyContent === null) return {
-		ok: false,
-		failure: {
-			kind: "no-content",
-			message: "bridge reply carries no message content"
-		}
-	};
-	const rawUsage = primeReplyUsage(response);
-	return {
-		ok: true,
-		content: replyContent,
-		usage: normalizePrimeUsage(rawUsage),
-		rawUsage
-	};
-}
-/**
-* Fold from the FIRST turn, never from an empty receipt: an all-null identity
-* would poison every side it merged with and erase counts the bridge reported.
-*/
-function mergeTurns(turns) {
-	if (turns.length === 0) return emptyPrimeRawUsage();
-	return turns.slice(1).reduce((total, turn) => mergePrimeRawUsage(total, turn.usage), turns[0].usage);
-}
-function primeReplyContent(response) {
-	if (typeof response !== "object" || response === null) return null;
-	const choices = response.choices;
-	if (!Array.isArray(choices) || choices.length === 0) return null;
-	const message = choices[0]?.message;
-	if (typeof message !== "object" || message === null) return null;
-	const content = message.content;
-	return typeof content === "string" && content.length > 0 ? content : null;
-}
-function primeReplyUsage(response) {
-	if (typeof response !== "object" || response === null) return null;
-	return response.usage ?? null;
-}
-/**
-* Render, measure, fall back to the capped projection, re-measure, fail loud.
-*
-* Inline is the only delivery prime has, so an oversized trajectory is a
-* refusal rather than a silent truncation: dropping spans would understate the
-* trajectory and the analyst would answer a question about a different run.
-*/
-async function projectPrimeTrajectory(source, limits) {
-	let fetch = "full";
-	let items = await source.full();
-	if (items === null) {
-		fetch = "capped";
-		items = await source.capped();
-	}
-	let rendered = JSON.stringify(items);
-	if (rendered.length > limits.maxInlineChars && fetch === "full") {
-		fetch = "capped";
-		items = await source.capped();
-		rendered = JSON.stringify(items);
-	}
-	if (rendered.length > limits.maxInlineChars) return {
-		ok: false,
-		reason: `trajectory renders to ${rendered.length} chars even at ${source.cappedDescription}; inline delivery impossible`,
-		renderedChars: rendered.length
-	};
-	return {
-		ok: true,
-		items,
-		rendered,
-		delivery: {
-			mode: "inline-json",
-			fetch,
-			renderedChars: rendered.length
-		}
-	};
-}
-/**
-* Digest of everything a consumer can send to the bridge under the prime
-* protocol, recorded per observation so a prime result names the exact contract
-* that produced it.
-*
-* Computed over the ACTUALLY composed contract, so two consumers that both
-* stamp `analyst_id: 'prime'` while asking materially different questions get
-* different digests by construction. That is what makes 'prime' a reproducible
-* claim rather than a label.
-*/
-function primeProtocolSha256(identity) {
-	return createHash("sha256").update(JSON.stringify({
-		kind: "prime-analyst-protocol",
-		question: identity.question,
-		taskPrompt: identity.taskDefinition ?? null,
-		outputContract: identity.contractLines,
-		repairContract: buildPrimeRepairPrompt({
-			defect: "<defect>",
-			previousReply: "<previous-reply>",
-			repairContractLines: identity.repairContractLines
-		}),
-		limits: identity.limits
-	})).digest("hex");
-}
-//#endregion
 //#region src/analyst/benchmark-runner-prime.ts
 /**
 * Prime analyst arm: the RLM coding agent reached through an OpenAI-compatible
 * cli-bridge solves the CodeTraceBench incorrect-step task as a one-shot trace
 * analyst.
 *
-* The runner consumes the same prepared benchmark cases every other runner
-* receives — the trace store already carries the appended final-verification
-* spans — and produces findings through the same published block expansion, so
-* a prime observation and a dspy-rlm observation differ only in which analyst
-* produced the blocks.
+* The arm is expressed as an `AnalystDefinition`
+* (`primeCodeTraceAnalystDefinition`): the question, task text, output
+* contract, inline projection budget, and repair-turn declaration are all
+* definition content, and `createPrimeBenchmarkRunner` is a thin shell that
+* builds the definition and runs it through the inline strategy below. The
+* same strategy is what `bindAnalyst` (./bind) dispatches to, so a compiled
+* definition and this entry point send byte-identical requests — the parity
+* suite asserts exactly that.
 *
-* The protocol itself — prompt composition, the bounded repair turn, reply
+* The protocol machinery — prompt composition, the bounded repair turn, reply
 * extraction, the projection ladder, usage normalization — lives in
-* `./prime-protocol`, which knows nothing about CodeTraceBench. This file is
-* the benchmark's binding to it: the block row grammar, the store-backed
-* projection source, and the benchmark observation shape.
+* `./prime-protocol`, which knows nothing about CodeTraceBench. This file adds
+* the benchmark's binding to it (block row grammar, store-backed projection,
+* observation shape) plus the projection-generic inline execution strategy.
 *
 * Trajectory delivery is inline JSON in the prompt. The dspy typed path binds
 * the viewTrace span projection as a REPL variable; prime has no REPL, so the
 * same projection is serialized into the prompt. When the full projection is
-* oversized the runner falls back to chunked viewSpans over the same
+* oversized the strategy falls back to chunked viewSpans over the same
 * projection surface with a per-attribute byte cap, and fails loud if the
 * result still exceeds the inline budget.
 *
@@ -5441,56 +5427,142 @@ const PRIME_BLOCK_CONTRACT = {
 	}
 };
 /**
-* Digest of everything this runner can send to the bridge, recorded per
+* Digest of everything this arm can send to the bridge, recorded per
 * observation so a prime result names the exact contract that produced it.
 */
 function primeAnalystProtocolSha256() {
 	return primeProtocolSha256(PRIME_PROTOCOL_IDENTITY);
 }
-/** CodeTraceBench-only: the prompt and output contract speak its block grammar. */
+/**
+* The prime arm as a declarative unit. CodeTraceBench-only: the question,
+* task text, and block grammar speak its incorrect-step definition.
+*/
+function primeCodeTraceAnalystDefinition(args) {
+	return {
+		id: PRIME_ANALYST_ID,
+		description: "One-shot RLM over an OpenAI-compatible bridge answering the CodeTraceBench incorrect-step task.",
+		version: "1.0.0",
+		area: "incorrect",
+		profile: {},
+		question: PRIME_QUESTION,
+		taskDefinition: CODE_TRACE_BENCH_ANALYST_PROMPT,
+		projection: {
+			mode: "inline",
+			maxInlineChars: MAX_INLINE_TRAJECTORY_CHARS,
+			cappedAttributeBytes: CHUNKED_PROJECTION_ATTRIBUTE_BYTE_CAP
+		},
+		replyContract: PRIME_BLOCK_CONTRACT,
+		contractLimits: {
+			maxBlocks: 16,
+			maxBlockSteps: 12
+		},
+		budget: { timeoutMs: args.timeoutMs },
+		repair: { turns: args.repairTurns },
+		protocolSha256: primeAnalystProtocolSha256(),
+		binding: {
+			kind: "inline",
+			subjectFromCaseId: trajectoryIdFromCaseId,
+			baseMetadata: {
+				analysisMode: "prime-rlm",
+				engine: "prime"
+			},
+			header(subject, spans) {
+				const stepSpans = spans.filter((span) => /^step-\d+$/.test(String(span.span_id)));
+				if (stepSpans.length === 0) throw new PrimeTraceProjectionError(`no step-<n> spans in trace '${subject}'`);
+				return `TRAJECTORY (trace_id ${subject}; ${stepSpans.length} assistant step spans; full span projection as JSON):`;
+			},
+			trailer(_subject, spans) {
+				const finalVerification = spans.filter(isFinalVerificationSpan);
+				return finalVerification.length > 0 ? `FINAL VERIFICATION SPANS:\n${JSON.stringify(finalVerification)}` : "FINAL VERIFICATION: unavailable for this trajectory — trace backward from the latest failure evidence inside the trajectory itself.";
+			},
+			async expandRows({ subject, rows, store, analystId, signal }) {
+				const expanded = await expandCodeTraceFailureBlocks({
+					trajectoryId: subject,
+					blocks: rows,
+					store,
+					analystId,
+					...signal ? { signal } : {}
+				});
+				return {
+					findings: expanded.findings,
+					diagnostics: expanded.diagnostics
+				};
+			}
+		}
+	};
+}
+/** Thin shell: validate options, declare the definition, run the inline strategy. */
 function createPrimeBenchmarkRunner(options) {
-	const baseUrl = requiredString(options.baseUrl, "baseUrl").replace(/\/+$/, "");
-	const model = requiredString(options.model, "model");
 	const timeoutMs = positiveSafeInteger(options.timeoutMs, "timeoutMs");
 	const repair = options.repair;
 	if (typeof repair !== "boolean") throw new TypeError("repair must be a boolean");
-	const pricing = options.pricing ?? pricingForModel(model);
-	const transport = options.transport ?? nodeHttpPrimeBridgeTransport();
+	return runInlineAnalystDefinition(primeCodeTraceAnalystDefinition({
+		timeoutMs,
+		repairTurns: repair ? 1 : 0
+	}), {
+		baseUrl: options.baseUrl,
+		model: options.model,
+		...options.transport ? { transport: options.transport } : {},
+		...options.pricing ? { pricing: options.pricing } : {}
+	});
+}
+/**
+* Compile an inline-projection definition into a runnable arm. Projection,
+* prompt composition, the bounded repair turn, and usage accounting are all
+* driven by the definition; nothing in this strategy names a benchmark.
+*/
+function runInlineAnalystDefinition(definition, transports) {
+	const { projection, binding } = definition;
+	if (projection.mode !== "inline" || binding.kind !== "inline") throw new AnalystExpressivenessError(`the inline strategy compiles only inline projections; definition '${definition.id}' declares projection '${projection.mode}' with a '${binding.kind}' binding`);
+	if (definition.repair.turns > 1) throw new AnalystExpressivenessError(`the inline exchange grants at most one bounded repair turn; definition '${definition.id}' declares ${definition.repair.turns}`);
+	const baseUrl = requiredString(transports.baseUrl, "baseUrl").replace(/\/+$/, "");
+	const model = requiredString(transports.model, "model");
+	const timeoutMs = positiveSafeInteger(definition.budget.timeoutMs, "timeoutMs");
+	const repair = definition.repair.turns === 1;
+	const pricing = transports.pricing ?? pricingForModel(model);
+	const transport = transports.transport ?? nodeHttpPrimeBridgeTransport();
 	const url = `${baseUrl}/v1/chat/completions`;
 	return {
-		id: PRIME_ANALYST_ID,
+		id: definition.id,
 		async analyze(input, context) {
-			const trajectoryId = trajectoryIdFromCaseId(context.caseId);
+			const subject = binding.subjectFromCaseId(context.caseId);
 			let usage;
 			let metadata = {
-				analysisMode: "prime-rlm",
-				engine: "prime",
+				...binding.baseMetadata,
 				bridgeUrl: baseUrl,
 				model,
-				protocolSha256: primeAnalystProtocolSha256()
+				protocolSha256: definition.protocolSha256
 			};
 			try {
 				const store = input.traceStore;
-				if (!store) throw new Error("codetracebench prime runner requires a trace store");
-				const projection = await projectPrimeTrajectory(codeTraceProjectionSource(store, trajectoryId, context.signal ? { signal: context.signal } : void 0), { maxInlineChars: MAX_INLINE_TRAJECTORY_CHARS });
-				if (!projection.ok) throw new PrimeTraceProjectionError(projection.reason);
+				if (!store) throw new Error(`inline analyst '${definition.id}' requires a trace store`);
+				const storeContext = context.signal ? { signal: context.signal } : void 0;
+				const projected = await projectPrimeTrajectory(inlineProjectionSource(store, subject, projection.cappedAttributeBytes, storeContext), { maxInlineChars: projection.maxInlineChars });
+				if (!projected.ok) throw new PrimeTraceProjectionError(projected.reason);
 				const delivery = {
-					mode: projection.delivery.mode,
-					fetch: projection.delivery.fetch === "full" ? "view-trace" : "view-spans-chunked",
-					perAttributeByteCap: projection.delivery.fetch === "full" ? null : CHUNKED_PROJECTION_ATTRIBUTE_BYTE_CAP,
-					renderedChars: projection.delivery.renderedChars
+					mode: projected.delivery.mode,
+					fetch: projected.delivery.fetch === "full" ? "view-trace" : "view-spans-chunked",
+					perAttributeByteCap: projected.delivery.fetch === "full" ? null : projection.cappedAttributeBytes,
+					renderedChars: projected.delivery.renderedChars
 				};
 				metadata = {
 					...metadata,
 					delivery
 				};
-				const prompt = buildCodeTracePrompt(trajectoryId, projection.items, projection.rendered);
+				const prompt = buildPrimePrompt({
+					question: definition.question,
+					...definition.taskDefinition === void 0 ? {} : { taskDefinition: definition.taskDefinition },
+					contractLines: definition.replyContract.contractLines,
+					trajectoryHeader: binding.header(subject, projected.items),
+					renderedTrajectory: projected.rendered,
+					trailer: binding.trailer(subject, projected.items)
+				});
 				metadata = {
 					...metadata,
 					promptChars: prompt.length
 				};
 				const outcome = await runPrimeExchange({
-					contract: PRIME_BLOCK_CONTRACT,
+					contract: definition.replyContract,
 					prompt,
 					transport,
 					url,
@@ -5518,11 +5590,11 @@ function createPrimeBenchmarkRunner(options) {
 					};
 					throw primeFailureError(outcome.failure);
 				}
-				const expanded = await expandCodeTraceFailureBlocks({
-					trajectoryId,
-					blocks: outcome.rows,
+				const expanded = await binding.expandRows({
+					subject,
+					rows: outcome.rows,
 					store,
-					analystId: PRIME_ANALYST_ID,
+					analystId: definition.id,
 					...context.signal ? { signal: context.signal } : {}
 				});
 				return {
@@ -5553,13 +5625,13 @@ function createPrimeBenchmarkRunner(options) {
 * the full viewTrace projection, or the chunked viewSpans projection at a
 * per-attribute byte cap.
 */
-function codeTraceProjectionSource(store, trajectoryId, context) {
+function inlineProjectionSource(store, trajectoryId, cappedAttributeBytes, context) {
 	return {
 		async full() {
 			return (await store.viewTrace({ trace_id: trajectoryId }, context)).spans ?? null;
 		},
-		capped: () => projectSpansChunked(store, trajectoryId, context),
-		cappedDescription: `per-attribute cap ${CHUNKED_PROJECTION_ATTRIBUTE_BYTE_CAP}`
+		capped: () => projectSpansChunked(store, trajectoryId, cappedAttributeBytes, context),
+		cappedDescription: `per-attribute cap ${cappedAttributeBytes}`
 	};
 }
 /**
@@ -5568,7 +5640,7 @@ function codeTraceProjectionSource(store, trajectoryId, context) {
 * id must project or the case fails loud — a silently dropped span would
 * understate the trajectory.
 */
-async function projectSpansChunked(store, trajectoryId, context) {
+async function projectSpansChunked(store, trajectoryId, cappedAttributeBytes, context) {
 	const enumeration = await store.viewTrace({
 		trace_id: trajectoryId,
 		per_attribute_byte_cap: SPAN_ID_ENUMERATION_ATTRIBUTE_BYTE_CAP
@@ -5587,26 +5659,13 @@ async function projectSpansChunked(store, trajectoryId, context) {
 		const result = await store.viewSpans({
 			trace_id: trajectoryId,
 			span_ids: chunk,
-			per_attribute_byte_cap: CHUNKED_PROJECTION_ATTRIBUTE_BYTE_CAP
+			per_attribute_byte_cap: cappedAttributeBytes
 		}, context);
 		if (result.missing_span_ids.length > 0 || result.omitted_span_ids.length > 0 || result.spans.length !== chunk.length) throw new PrimeTraceProjectionError(`viewSpans projected ${result.spans.length}/${chunk.length} spans for chunk at ${index} of '${trajectoryId}'`);
 		projected.push(...result.spans);
 	}
 	return projected;
 }
-function buildCodeTracePrompt(trajectoryId, spans, renderedSpans) {
-	const stepSpans = spans.filter((span) => /^step-\d+$/.test(String(span.span_id)));
-	if (stepSpans.length === 0) throw new PrimeTraceProjectionError(`no step-<n> spans in trace '${trajectoryId}'`);
-	const finalVerification = spans.filter(isFinalVerificationSpan);
-	return buildPrimePrompt({
-		question: PRIME_QUESTION,
-		taskDefinition: CODE_TRACE_BENCH_ANALYST_PROMPT,
-		contractLines: PRIME_OUTPUT_CONTRACT_LINES,
-		trajectoryHeader: `TRAJECTORY (trace_id ${trajectoryId}; ${stepSpans.length} assistant step spans; full span projection as JSON):`,
-		renderedTrajectory: renderedSpans,
-		trailer: finalVerification.length > 0 ? `FINAL VERIFICATION SPANS:\n${JSON.stringify(finalVerification)}` : "FINAL VERIFICATION: unavailable for this trajectory — trace backward from the latest failure evidence inside the trajectory itself."
-	});
-}
 /** Map the protocol's terminal reason onto this benchmark's typed error classes. */
 function primeFailureError(failure) {
 	switch (failure.kind) {
@@ -6351,6 +6410,6 @@ function shellQuote(value) {
 	return /^[a-zA-Z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
 }
 //#endregion
-export { ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 as $, summarizeCodeTraceCalibration as A, publicBenchmarkSystemPrompt as B, createPublicBenchmarkRlmRunner as C, expandCodeTraceFailureBlocks as D, emptyPublicBenchmarkRunner as E, CODE_TRACE_BENCH_ANALYST_PROMPT as F, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM as G, appendVerificationArtifactsToOtlp as H, MAX_INCORRECT_BLOCKS as I, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 as J, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES as K, MAX_INCORRECT_BLOCK_STEPS as L, analystInstructionsOverrideFromText as M, effectiveAnalystProtocolSha256 as N, readAnalystBenchmarkArtifact as O, readAnalystInstructionsOverride as P, ANALYST_BENCHMARK_IMPLEMENTATION_FILES as Q, publicBenchmarkProtocolSha256 as R, selectPublicBenchmarkRows as S, adaptPublicBenchmarkFindings as T, loadCodeTraceVerificationArtifacts as U, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES as V, parseVerificationOutcome as W, ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION as X, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 as Y, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM as Z, nodeHttpPrimeBridgeTransport as _, primeAnalystProtocolSha256 as a, ANALYST_BENCHMARK_OBSERVATIONS_FILE as at, publicBenchmarkDistributions as b, buildPrimeRepairPrompt as c, summarizeAgentRxCalibration as ct, mergePrimeRawUsage as d, agentRxBenchmarkCase as dt, analystBenchmarkDependencyLockDigest as et, normalizePrimeUsage as f, agentRxPredictionsToFindings as ft, runPrimeExchange as g, projectPrimeTrajectory as h, normalizeBenchmarkLabel as ht, createPrimeBenchmarkRunner as i, ANALYST_BENCHMARK_MANIFEST_FILE as it, compareAnalystRunners as j, renderCodeTraceCalibrationMarkdown as k, emptyPrimeRawUsage as l, codeTraceBenchCase as lt, primeReplyDefect as m, roundAgentRxStep as mt, runAnalystBenchmarkCommand as n, ANALYST_BENCHMARK_COST_LEDGER_FILE as nt, analystUsageReceiptFromPrimeUsage as o, AGENT_RX_UPSTREAM_REVISION as ot, primeProtocolSha256 as p, normalizeAgentRxCategory as pt, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 as q, renderAnalystBenchmarkMarkdown as r, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE as rt, buildPrimePrompt as s, renderAgentRxCalibrationMarkdown as st, ANALYST_BENCHMARK_HELP as t, analystBenchmarkImplementationDigest as tt, extractPrimeJsonObject as u, codeTracerPredictionsToFindings as ut, loadPublicBenchmarkRows as v, createPublicBenchmarkDirectRunner as w, publicBenchmarkSelectionReport as x, preparePublicAnalystBenchmark as y, publicBenchmarkRlmInstructions as z };
+export { ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 as $, summarizeCodeTraceCalibration as A, publicBenchmarkSystemPrompt as B, analystDefinitionAsymmetries as C, expandCodeTraceFailureBlocks as D, emptyPublicBenchmarkRunner as E, CODE_TRACE_BENCH_ANALYST_PROMPT as F, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM as G, appendVerificationArtifactsToOtlp as H, MAX_INCORRECT_BLOCKS as I, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 as J, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES as K, MAX_INCORRECT_BLOCK_STEPS as L, analystInstructionsOverrideFromText as M, effectiveAnalystProtocolSha256 as N, readAnalystBenchmarkArtifact as O, readAnalystInstructionsOverride as P, ANALYST_BENCHMARK_IMPLEMENTATION_FILES as Q, publicBenchmarkProtocolSha256 as R, AnalystExpressivenessError as S, adaptPublicBenchmarkFindings as T, loadCodeTraceVerificationArtifacts as U, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES as V, parseVerificationOutcome as W, ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION as X, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 as Y, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM as Z, runReplVariableAnalystDefinition as _, primeAnalystProtocolSha256 as a, ANALYST_BENCHMARK_OBSERVATIONS_FILE as at, runChunkedAnalystDefinition as b, nodeHttpPrimeBridgeTransport as c, summarizeAgentRxCalibration as ct, publicBenchmarkDistributions as d, agentRxBenchmarkCase as dt, analystBenchmarkDependencyLockDigest as et, publicBenchmarkSelectionReport as f, agentRxPredictionsToFindings as ft, rlmEngineLimits as g, publicRlmAnalystDefinition as h, normalizeBenchmarkLabel as ht, createPrimeBenchmarkRunner as i, ANALYST_BENCHMARK_MANIFEST_FILE as it, compareAnalystRunners as j, renderCodeTraceCalibrationMarkdown as k, loadPublicBenchmarkRows as l, codeTraceBenchCase as lt, createPublicBenchmarkRlmRunner as m, roundAgentRxStep as mt, runAnalystBenchmarkCommand as n, ANALYST_BENCHMARK_COST_LEDGER_FILE as nt, primeCodeTraceAnalystDefinition as o, AGENT_RX_UPSTREAM_REVISION as ot, selectPublicBenchmarkRows as p, normalizeAgentRxCategory as pt, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 as q, renderAnalystBenchmarkMarkdown as r, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE as rt, runInlineAnalystDefinition as s, renderAgentRxCalibrationMarkdown as st, ANALYST_BENCHMARK_HELP as t, analystBenchmarkImplementationDigest as tt, preparePublicAnalystBenchmark as u, codeTracerPredictionsToFindings as ut, createPublicBenchmarkDirectRunner as v, analystDefinitionProtocolSha256 as w, decodeReplyRows as x, publicDirectAnalystDefinition as y, publicBenchmarkRlmInstructions as z };
 
-//# sourceMappingURL=benchmark-command-CA_NFOmy.js.map
+//# sourceMappingURL=benchmark-command-BCafwNrf.js.map