@tangle-network/agent-eval 0.144.3 → 0.144.5

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

@@ -2,24 +2,26 @@ 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-Bvwe3pup.js";
-import { o as makeFinding, r as usageReceiptFromCostLedger } from "./usage-receipt-CgxMEBZq.js";
+import { O as evidenceRefsFromRawFinding, 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-IRCG8kdi.js";
+import { t as createDspyRlmTraceEngine } from "./dspy-rlm-engine-19FQEMBK.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-D4I90_vR.js";
-import { i as summarizeAnalystBenchmarkRunner, n as runAnalystBenchmark, r as traceStoreEvidenceResolver } from "./benchmark-CYtcIF2V.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 { z } from "zod";
 import { constants, existsSync, lstatSync, readFileSync } from "node:fs";
 import * as nodePath from "node:path";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
+import { request } from "node:http";
 import { link, lstat, mkdir, open, readFile, readdir, realpath, stat, unlink } from "node:fs/promises";
 import { arch, platform } from "node:os";
 import { TextDecoder as TextDecoder$1 } from "node:util";
 import { pathToFileURL } from "node:url";
+import { request as request$1 } from "node:https";
 //#region src/analyst/benchmark-dataset-utils.ts
 function normalizeBenchmarkLabel(value) {
 	const normalized = nonEmpty$1(value, "benchmark label").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -706,7 +708,12 @@ const usageSchema = z.strictObject({
 	calls: nonNegativeInteger.nullable(),
 	tokens: tokenUsageSchema.nullable(),
 	cost: costSchema,
-	knownCostUsd: nonNegativeNumber.optional()
+	knownCostUsd: nonNegativeNumber.optional(),
+	partialTokens: z.strictObject({
+		input: nonNegativeInteger.nullable(),
+		output: nonNegativeInteger.nullable()
+	}).optional(),
+	tokensEstimated: z.boolean().optional()
 });
 const findingScoreSchema = z.strictObject({
 	expectedIssueCount: nonNegativeInteger,
@@ -1200,7 +1207,7 @@ const ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES = Object.freeze([
 	"package.json",
 	"pnpm-lock.yaml"
 ]);
-const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "f0d788f72ea83b6bd485f2ae61e58dda7e1d87ec79284ce245b3a7f0cc7ca812";
+const ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 = "4785a1e0d785431f287362808dae777cf73125c551c18260117a711a5f2a6263";
 /** 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
@@ -1239,6 +1246,7 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/analyst/benchmark-real-model.ts",
 	"src/analyst/benchmark-report.ts",
 	"src/analyst/benchmark-response-cache.ts",
+	"src/analyst/benchmark-runner-prime.ts",
 	"src/analyst/benchmark-scoring.ts",
 	"src/analyst/benchmark-summary.ts",
 	"src/analyst/benchmark-verification-artifacts.ts",
@@ -1251,6 +1259,8 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/analyst/finding-subject.ts",
 	"src/analyst/kind-factory.ts",
 	"src/analyst/parse-tolerant.ts",
+	"src/analyst/prime-bridge-transport.ts",
+	"src/analyst/prime-protocol.ts",
 	"src/analyst/tool-groups.ts",
 	"src/analyst/trace-tool-callback.ts",
 	"src/analyst/types.ts",
@@ -1299,7 +1309,7 @@ const ANALYST_BENCHMARK_IMPLEMENTATION_FILES = Object.freeze([
 	"src/trace/raw-provider-sink.ts",
 	"src/verdict-cache.ts"
 ]);
-const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "67cd83aaaa158d44a9fa32e172cbe68fa97f01ae673ccb117469688b628bb9b1";
+const ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 = "46af7a98d6df73d845394827283390bac7a2fb9712f418b14b1093f19a21faea";
 function analystBenchmarkImplementationDigest() {
 	return ANALYST_BENCHMARK_IMPLEMENTATION_SHA256;
 }
@@ -2437,7 +2447,7 @@ function createLocalRunReceipt(config, paths) {
 			traceDir: resolve(config.traceDir),
 			...config.artifactDir ? { artifactDir: resolve(config.artifactDir) } : {},
 			outputDir: paths.directory,
-			modelOwnerModule: config.modelOwnerModule
+			...config.modelOwnerModule === void 0 ? {} : { modelOwnerModule: config.modelOwnerModule }
 		},
 		command: config.command,
 		environment: {
@@ -3596,7 +3606,7 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 	const maxModelRequestBytes = config.maxModelRequestBytes ?? 16 * 1024 * 1024;
 	const maxModelResponseBytes = config.maxModelResponseBytes ?? 4 * 1024 * 1024;
 	const modelRequestTimeoutMs = config.modelRequestTimeoutMs ?? timeoutMs;
-	const pricing = config.pricing ?? pricingForModel$1(model);
+	const pricing = config.pricing ?? pricingForModel$2(model);
 	const maxCostUsd = config.maxCostUsdPerAnalysis ?? 1;
 	const costLedger = config.costLedger ?? new CostLedger();
 	const durability = config.durability ? {
@@ -3608,7 +3618,7 @@ function createPublicBenchmarkDirectRunner(dataset, config) {
 	return {
 		id: "direct",
 		async analyze(input, context) {
-			const trajectoryId = trajectoryIdFromCaseId$1(dataset, context.caseId);
+			const trajectoryId = trajectoryIdFromCaseId$2(dataset, context.caseId);
 			const costTags = {
 				analystId: actor,
 				benchmarkCaseId: context.caseId,
@@ -3920,7 +3930,7 @@ function costReceiptMetadata(receipt) {
 		estimatedCostUsd: null
 	};
 }
-function pricingForModel$1(model) {
+function pricingForModel$2(model) {
 	const pricing = resolveModelPricing(model);
 	if (!pricing) throw new Error(`no pricing is configured for '${model}'; provide PublicAnalystBenchmarkModelConfig.pricing`);
 	return {
@@ -4096,7 +4106,7 @@ async function prepareSingleTraceContext(store, context) {
 		});
 	}
 }
-function trajectoryIdFromCaseId$1(dataset, caseId) {
+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}'`);
 	return caseId.slice(prefix.length);
@@ -4245,7 +4255,7 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 		maxToolCalls: config.dspyRlm?.maxToolCalls ?? 80,
 		maxOutputChars: config.dspyRlm?.maxOutputChars ?? 8e3
 	};
-	const pricing = config.pricing ?? pricingForModel(config.model);
+	const pricing = config.pricing ?? pricingForModel$1(config.model);
 	const engine = createDspyRlmTraceEngine({
 		call: config.call,
 		callRef: config.callRef,
@@ -4278,7 +4288,7 @@ function createPublicBenchmarkRlmRunner(dataset, config) {
 	return {
 		id: "dspy-rlm",
 		async analyze(input, context) {
-			const trajectoryId = trajectoryIdFromCaseId(dataset, context.caseId);
+			const trajectoryId = trajectoryIdFromCaseId$1(dataset, context.caseId);
 			const tags = {
 				benchmarkCaseId: context.caseId,
 				benchmarkRepetition: String(context.repetition)
@@ -4518,7 +4528,7 @@ function publicBenchmarkDefinition(dataset, limits, instructions) {
 		limits
 	};
 }
-function pricingForModel(model) {
+function pricingForModel$1(model) {
 	const pricing = resolveModelPricing(model);
 	if (!pricing) throw new Error(`no pricing is configured for '${model}'; provide PublicAnalystBenchmarkModelConfig.pricing`);
 	return {
@@ -4526,7 +4536,7 @@ function pricingForModel(model) {
 		outputUsdPerMillion: pricing.output * 1e3
 	};
 }
-function trajectoryIdFromCaseId(dataset, caseId) {
+function trajectoryIdFromCaseId$1(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}'`);
 	return caseId.slice(prefix.length);
@@ -4843,6 +4853,832 @@ function rootAgent(row) {
 	return scalarDistributionValue(row.failures.find((failure) => String(failure.failure_id) === String(rootCauseId))?.failed_agent);
 }
 //#endregion
+//#region src/analyst/prime-bridge-transport.ts
+/**
+* Default transport on node:http/node:https rather than fetch: undici's fixed
+* response-header timeout kills prime calls that legitimately run past five
+* minutes, so the request's AbortSignal is the only deadline.
+*/
+function nodeHttpPrimeBridgeTransport() {
+	return ({ url, body, signal }) => {
+		const target = new URL(url);
+		if (target.protocol !== "http:" && target.protocol !== "https:") throw new TypeError(`bridge URL must be http: or https:, got ${target.protocol}`);
+		const send = target.protocol === "https:" ? request$1 : request;
+		const encoded = JSON.stringify(body);
+		return new Promise((resolvePromise, rejectPromise) => {
+			const req = send({
+				hostname: target.hostname,
+				port: target.port,
+				path: `${target.pathname}${target.search}`,
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"content-length": Buffer.byteLength(encoded)
+				},
+				signal
+			}, (res) => {
+				const chunks = [];
+				res.on("data", (chunk) => chunks.push(chunk));
+				res.on("end", () => resolvePromise({
+					status: res.statusCode ?? 0,
+					text: Buffer.concat(chunks).toString("utf8")
+				}));
+				res.on("error", rejectPromise);
+			});
+			req.on("error", rejectPromise);
+			req.end(encoded);
+		});
+	};
+}
+//#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 protocol itself — 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.
+*
+* 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
+* projection surface with a per-attribute byte cap, and fails loud if the
+* result still exceeds the inline budget.
+*
+* A structurally malformed reply gets ONE bounded repair turn (disable with
+* `repair: false`): a second stateless call carrying the malformed reply plus
+* the output contract — never the trajectory — mirroring the dspy arm's typed
+* repair so both arms face the same structured-output affordance. Still
+* malformed after repair = failed observation with a typed error, exactly how
+* a dspy-rlm failure is recorded. Zero valid blocks from a well-formed reply
+* is an honest null, not a failure.
+*/
+const PRIME_ANALYST_ID = "prime";
+const PRIME_QUESTION = "Which assistant steps are incorrect under the CodeTraceBench definition?";
+/** Ceiling on the serialized trajectory JSON embedded in the prompt. */
+const MAX_INLINE_TRAJECTORY_CHARS = 36e4;
+/** Per-attribute projection cap used by the chunked viewSpans fallback. */
+const CHUNKED_PROJECTION_ATTRIBUTE_BYTE_CAP = 1200;
+/** Minimal per-attribute cap used only to enumerate span ids in store order. */
+const SPAN_ID_ENUMERATION_ATTRIBUTE_BYTE_CAP = 64;
+/** viewSpans accepts at most 100 ids per call; 40 keeps each response bounded. */
+const VIEW_SPANS_CHUNK_SIZE = 40;
+const PRIME_SEVERITIES = /* @__PURE__ */ new Set([
+	"critical",
+	"high",
+	"medium",
+	"low",
+	"info"
+]);
+var PrimeBridgeTransportError = class extends Error {};
+var PrimeBridgeHttpError = class extends Error {
+	status;
+	constructor(status, bodySnippet) {
+		super(`bridge HTTP ${status}: ${bodySnippet}`);
+		this.status = status;
+	}
+};
+var PrimeMalformedReplyError = class extends Error {};
+var PrimeTraceProjectionError = class extends Error {};
+/**
+* Short-strings rule: long reply strings get corrupted when the bridge splices
+* its backend's stream, so the contract forbids a rationale field and caps
+* every string the model must emit.
+*/
+const PRIME_OUTPUT_CONTRACT_LINES = [
+	"OUTPUT CONTRACT (supersedes any transport wording above — you have no trace tools and no REPL):",
+	"You are a one-shot analyst. Every fact you need is in the TRAJECTORY JSON below.",
+	"Do not run shell commands, do not read or write files, do not use any tools.",
+	"Reply with EXACTLY one fenced ```json code block and no other fenced block. The JSON object has exactly two fields:",
+	"  \"answer\": string — ONE short sentence (max 300 chars) naming the latest failure evidence you traced from.",
+	"  \"blocks\": array (possibly empty) of failure blocks, each exactly:",
+	"    {\"first_step\": int, \"last_step\": int, \"consequence_step\": int,",
+	"     \"escape_status\": \"escaped\"|\"unescaped\",",
+	"     \"severity\": \"critical\"|\"high\"|\"medium\"|\"low\"|\"info\",",
+	"     \"claim\": string (ONE short sentence, max 200 chars),",
+	"     \"confidence\": number 0..1}",
+	"Do NOT include a rationale field. Keep every string SHORT — long strings get corrupted in transport and void your work.",
+	`Report at most 16 blocks; a block spans at most 12 steps.`,
+	"Every step number must be the n of an existing assistant span with span_id \"step-<n>\" and kind \"LLM\" in the trajectory below; never cite TOOL, CHAIN, or AGENT spans.",
+	"\"blocks\" is [] only for a clean trajectory."
+];
+const PRIME_REPAIR_CONTRACT_LINES = [
+	"  \"answer\": string (ONE short sentence, max 300 chars)",
+	"  \"blocks\": array (possibly empty) of {\"first_step\": int, \"last_step\": int, \"consequence_step\": int,",
+	"   \"escape_status\": \"escaped\"|\"unescaped\", \"severity\": \"critical\"|\"high\"|\"medium\"|\"low\"|\"info\",",
+	"   \"claim\": string (max 200 chars), \"confidence\": number 0..1}",
+	"No rationale field. Keep every string SHORT. Preserve the step numbers and verdicts of your previous reply exactly; shorten prose freely."
+];
+const PRIME_PROTOCOL_IDENTITY = {
+	question: PRIME_QUESTION,
+	taskDefinition: CODE_TRACE_BENCH_ANALYST_PROMPT,
+	contractLines: PRIME_OUTPUT_CONTRACT_LINES,
+	repairContractLines: PRIME_REPAIR_CONTRACT_LINES,
+	limits: {
+		maxBlocks: 16,
+		maxBlockSteps: 12,
+		maxInlineTrajectoryChars: MAX_INLINE_TRAJECTORY_CHARS,
+		chunkedProjectionAttributeByteCap: CHUNKED_PROJECTION_ATTRIBUTE_BYTE_CAP
+	}
+};
+/**
+* The block row grammar. No `maxRows`: the count cap belongs to
+* `expandCodeTraceFailureBlocks`, which drops the offending block and names it
+* in `diagnostics.droppedBlocks`, so capping here would erase that record.
+*/
+const PRIME_BLOCK_CONTRACT = {
+	rowsField: "blocks",
+	contractLines: PRIME_OUTPUT_CONTRACT_LINES,
+	repairContractLines: PRIME_REPAIR_CONTRACT_LINES,
+	decodeRow(row) {
+		const reason = blockRowDefect(row);
+		if (reason !== null) return {
+			ok: false,
+			reason
+		};
+		return {
+			ok: true,
+			row: blockFromRow(row)
+		};
+	}
+};
+/**
+* Digest of everything this runner 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. */
+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();
+	const url = `${baseUrl}/v1/chat/completions`;
+	return {
+		id: PRIME_ANALYST_ID,
+		async analyze(input, context) {
+			const trajectoryId = trajectoryIdFromCaseId(context.caseId);
+			let usage;
+			let metadata = {
+				analysisMode: "prime-rlm",
+				engine: "prime",
+				bridgeUrl: baseUrl,
+				model,
+				protocolSha256: primeAnalystProtocolSha256()
+			};
+			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);
+				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
+				};
+				metadata = {
+					...metadata,
+					delivery
+				};
+				const prompt = buildCodeTracePrompt(trajectoryId, projection.items, projection.rendered);
+				metadata = {
+					...metadata,
+					promptChars: prompt.length
+				};
+				const outcome = await runPrimeExchange({
+					contract: PRIME_BLOCK_CONTRACT,
+					prompt,
+					transport,
+					url,
+					model,
+					timeoutMs,
+					repair,
+					...context.signal ? { signal: context.signal } : {}
+				});
+				if (!outcome.ok && outcome.failure.kind === "aborted") throw abortCause(outcome.failure);
+				if (outcome.turns.length > 0) {
+					usage = analystUsageReceiptFromPrimeUsage(outcome.usage, pricing);
+					metadata = {
+						...metadata,
+						bridgeUsage: bridgeUsageFromTurns(outcome.turns)
+					};
+				}
+				metadata = {
+					...metadata,
+					repair: outcome.repair
+				};
+				if (!outcome.ok) {
+					if (outcome.reply !== void 0) metadata = {
+						...metadata,
+						reply: outcome.reply.slice(0, 4e3)
+					};
+					throw primeFailureError(outcome.failure);
+				}
+				const expanded = await expandCodeTraceFailureBlocks({
+					trajectoryId,
+					blocks: outcome.rows,
+					store,
+					analystId: PRIME_ANALYST_ID,
+					...context.signal ? { signal: context.signal } : {}
+				});
+				return {
+					findings: expanded.findings,
+					usage,
+					metadata: {
+						...metadata,
+						answer: outcome.answer,
+						reportedRows: outcome.reportedRows,
+						rejectedRows: outcome.rejected,
+						blockDiagnostics: expanded.diagnostics
+					}
+				};
+			} catch (error) {
+				if (context.signal?.aborted) throw error;
+				return {
+					findings: [],
+					...usage ? { usage } : {},
+					error: publicBenchmarkError(error, []),
+					metadata
+				};
+			}
+		}
+	};
+}
+/**
+* The trace store, seen through the protocol's two-move projection contract:
+* the full viewTrace projection, or the chunked viewSpans projection at a
+* per-attribute byte cap.
+*/
+function codeTraceProjectionSource(store, trajectoryId, 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}`
+	};
+}
+/**
+* Chunked viewSpans projection for traces whose full viewTrace response is
+* oversized. Span ids come from a minimal-cap viewTrace in store order; every
+* id must project or the case fails loud — a silently dropped span would
+* understate the trajectory.
+*/
+async function projectSpansChunked(store, trajectoryId, context) {
+	const enumeration = await store.viewTrace({
+		trace_id: trajectoryId,
+		per_attribute_byte_cap: SPAN_ID_ENUMERATION_ATTRIBUTE_BYTE_CAP
+	}, context);
+	if (!enumeration.spans) throw new PrimeTraceProjectionError(`trace '${trajectoryId}' is oversized even at per-attribute cap ${SPAN_ID_ENUMERATION_ATTRIBUTE_BYTE_CAP}; cannot enumerate span ids`);
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const span of enumeration.spans) if (typeof span.span_id === "string" && span.span_id.length > 0 && !seen.has(span.span_id)) {
+		seen.add(span.span_id);
+		ids.push(span.span_id);
+	}
+	if (ids.length === 0) throw new PrimeTraceProjectionError(`no span ids parsed from trace '${trajectoryId}'`);
+	const projected = [];
+	for (let index = 0; index < ids.length; index += VIEW_SPANS_CHUNK_SIZE) {
+		const chunk = ids.slice(index, index + VIEW_SPANS_CHUNK_SIZE);
+		const result = await store.viewSpans({
+			trace_id: trajectoryId,
+			span_ids: chunk,
+			per_attribute_byte_cap: CHUNKED_PROJECTION_ATTRIBUTE_BYTE_CAP
+		}, 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) {
+		case "http-status": return new PrimeBridgeHttpError(failure.status, failure.bodySnippet);
+		case "malformed-reply": return new PrimeMalformedReplyError(failure.message);
+		default: return new PrimeBridgeTransportError(failure.message);
+	}
+}
+/** A cancelled run is not a result: the caller's error propagates unchanged. */
+function abortCause(failure) {
+	return failure.cause instanceof Error ? failure.cause : new Error(failure.message);
+}
+function bridgeUsageFromTurns(turns) {
+	return {
+		first: turns.find((turn) => turn.turn === "first")?.rawUsage ?? null,
+		repair: turns.find((turn) => turn.turn === "repair")?.rawUsage ?? null
+	};
+}
+function isFinalVerificationSpan(span) {
+	if (span.span_id.startsWith("benchmark-verification")) return true;
+	const role = span.attributes["benchmark.evidence.role"];
+	return typeof role === "string" && role.startsWith("final-verification");
+}
+function trajectoryIdFromCaseId(caseId) {
+	if (!caseId.startsWith("codetrace:") || caseId.length === 10) throw new Error(`unexpected codetracebench benchmark case id '${caseId}'`);
+	return caseId.slice(10);
+}
+function blockRowDefect(row) {
+	if (typeof row !== "object" || row === null || Array.isArray(row)) return "row is not an object";
+	const record = row;
+	for (const field of [
+		"first_step",
+		"last_step",
+		"consequence_step"
+	]) {
+		const value = record[field];
+		if (!Number.isInteger(value) || value < 1) return `${field} must be a positive integer`;
+	}
+	const firstStep = record.first_step;
+	const lastStep = record.last_step;
+	const consequenceStep = record.consequence_step;
+	if (lastStep < firstStep) return "last_step < first_step";
+	if (consequenceStep < firstStep) return "consequence_step < first_step";
+	if (lastStep - firstStep + 1 > 12) return `block spans ${lastStep - firstStep + 1} steps (cap 12)`;
+	if (record.escape_status !== "escaped" && record.escape_status !== "unescaped") return "escape_status must be escaped|unescaped";
+	if (typeof record.severity !== "string" || !PRIME_SEVERITIES.has(record.severity)) return "severity outside the analyst severity enum";
+	if (typeof record.claim !== "string" || record.claim.trim().length === 0 || record.claim.length > 2e3) return "claim must be a 1-2000 char string";
+	if (typeof record.confidence !== "number" || !Number.isFinite(record.confidence) || record.confidence < 0 || record.confidence > 1) return "confidence must be 0..1";
+	return null;
+}
+function blockFromRow(row) {
+	const rationale = typeof row.rationale === "string" && row.rationale.trim().length > 0 ? row.rationale.trim().slice(0, 4e3) : void 0;
+	return {
+		firstStep: row.first_step,
+		lastStep: row.last_step,
+		consequenceStep: row.consequence_step,
+		escapeStatus: row.escape_status,
+		severity: row.severity,
+		claim: row.claim.trim(),
+		confidence: row.confidence,
+		...rationale === void 0 ? {} : { rationale }
+	};
+}
+function pricingForModel(model) {
+	const pricing = resolveModelPricing(model);
+	if (!pricing) throw new Error(`no pricing is configured for '${model}'; provide PrimeBenchmarkRunnerOptions.pricing`);
+	return {
+		inputUsdPerMillion: pricing.input * 1e3,
+		outputUsdPerMillion: pricing.output * 1e3
+	};
+}
+//#endregion
 //#region src/analyst/benchmark-report.ts
 function renderAnalystBenchmarkMarkdown(result, comparisons = []) {
 	const { provenance } = result;
@@ -4973,7 +5809,20 @@ async function executeAnalystBenchmarkCommand(config, dependencies) {
 		return benchmarkExitCode(artifact.result, config.analyst);
 	}
 	if (await regularFileExists(paths.report)) throw new Error(`benchmark report exists without a completed result; refusing ambiguous resume: ${paths.report}`);
-	const createAnalystRunner = dependencies.createAnalystRunner ?? ((dataset, model) => config.analyst === "direct" ? createPublicBenchmarkDirectRunner(dataset, model) : createPublicBenchmarkRlmRunner(dataset, model));
+	const createAnalystRunner = dependencies.createAnalystRunner ?? ((dataset, model) => {
+		if (config.analyst === "prime") {
+			if (!config.prime) throw new Error("analyst 'prime' is missing its bridge configuration");
+			return createPrimeBenchmarkRunner({
+				baseUrl: config.prime.bridgeUrl,
+				model: model.model,
+				timeoutMs: model.timeoutMs,
+				repair: config.prime.repair,
+				...model.pricing ? { pricing: model.pricing } : {}
+			});
+		}
+		const ownerModel = requireModelOwnerSettings(model);
+		return config.analyst === "direct" ? createPublicBenchmarkDirectRunner(dataset, ownerModel) : createPublicBenchmarkRlmRunner(dataset, ownerModel);
+	});
 	const runners = [emptyPublicBenchmarkRunner(), createAnalystRunner(config.dataset, {
 		...config.model,
 		costLedger,
@@ -5143,21 +5992,31 @@ Run the recursive DSPy trace analyst against public AgentRx or CodeTraceBench la
 
 Required:
   --dataset agentrx|codetracebench
-  --analyst dspy-rlm|direct        Scored analyst. Default: dspy-rlm.
+  --analyst dspy-rlm|direct|prime  Scored analyst. Default: dspy-rlm.
                                    'direct' is the one-shot comparison arm.
+                                   'prime' is the RLM coding agent behind an
+                                   OpenAI-compatible cli-bridge (codetracebench
+                                   only; see docs/prime-analyst.md)
   --labels <dataset.json|dataset.jsonl>
   --trace-dir <one-trace-per-file OTLP JSONL directory>
   --artifact-dir <extracted artifact root>  Required for CodeTraceBench
   --out <new output directory>
   --revision <full 40- or 64-character hex digest>
   --split <dataset split>
-  --model-owner-module <module>   Module exporting createModelExecutionOwner;
-                                   the owner keeps provider credentials and policy
-  --model <provider model id>
+  --model-owner-module <module>   dspy-rlm|direct only. Module exporting
+                                   createModelExecutionOwner; the owner keeps
+                                   provider credentials and policy
+  --model <provider model id>      For prime, the bridge model id in
+                                   <backend>/<provider>/<model> form, e.g.
+                                   prime/zai/glm-5.2
   --limit <positive case count>
 
 Controls:
   --resume                         Continue an interrupted run in --out
+  --bridge-url <url>               prime only. OpenAI-compatible cli-bridge
+                                   base URL. Default: http://localhost:4181
+  --no-repair                      prime only. Disable the bounded repair turn
+                                   for a structurally malformed reply
   --seed <integer>                 Case-selection and comparison seed. Default: 0
   --concurrency <positive integer> Parallel benchmark jobs. Default: 1
   --repetitions <positive integer> Runs per case and runner. Default: 1
@@ -5207,7 +6066,17 @@ async function parseCommandConfig(argv, env, dependencies) {
 	const maxCostUsd = positiveFiniteFlag(flags, "max-cost-usd", 5);
 	const python = flags.get("python")?.trim();
 	const analyst = flags.get("analyst")?.trim() ?? "dspy-rlm";
-	if (analyst !== "dspy-rlm" && analyst !== "direct") throw new Error("--analyst must be 'dspy-rlm' or 'direct'");
+	if (analyst !== "dspy-rlm" && analyst !== "direct" && analyst !== "prime") throw new Error("--analyst must be 'dspy-rlm', 'direct', or 'prime'");
+	const bridgeUrl = flags.get("bridge-url")?.trim();
+	if (bridgeUrl !== void 0 && analyst !== "prime") throw new Error("--bridge-url requires --analyst prime");
+	if (bridgeUrl === "") throw new Error("--bridge-url must not be blank");
+	if (flags.has("no-repair") && analyst !== "prime") throw new Error("--no-repair requires --analyst prime");
+	if (analyst === "prime" && dataset !== "codetracebench") throw new Error("--analyst prime requires --dataset codetracebench; the prime runner speaks the CodeTraceBench failure-block contract");
+	if (analyst === "prime" && flags.has("model-owner-module")) throw new Error("--model-owner-module is not used by --analyst prime; the cli-bridge owns model execution");
+	const prime = analyst === "prime" ? {
+		bridgeUrl: bridgeUrl ?? "http://localhost:4181",
+		repair: !flags.has("no-repair")
+	} : void 0;
 	const rlmSamples = positiveFlag(flags, "rlm-samples", 1);
 	if (rlmSamples > 1 && analyst !== "dspy-rlm") throw new Error("--rlm-samples above 1 requires --analyst dspy-rlm");
 	const instructionsFile = flags.get("instructions-file")?.trim();
@@ -5215,13 +6084,13 @@ async function parseCommandConfig(argv, env, dependencies) {
 	const instructionsOverride = instructionsFile ? readAnalystInstructionsOverride(instructionsFile) : void 0;
 	if (rlmSamples > 1 && dataset !== "codetracebench") throw new Error("--rlm-samples above 1 requires --dataset codetracebench; step-level consensus is defined on its block grammar");
 	const model = requiredFlag(flags, "model");
-	const modelOwnerModule = requiredFlag(flags, "model-owner-module");
-	const owner = await (dependencies.loadModelExecutionOwner ?? loadModelExecutionOwner)(modelOwnerModule, {
+	const modelOwnerModule = analyst === "prime" ? void 0 : requiredFlag(flags, "model-owner-module");
+	const owner = modelOwnerModule ? await (dependencies.loadModelExecutionOwner ?? loadModelExecutionOwner)(modelOwnerModule, {
 		model,
 		environment: Object.freeze({ ...env })
-	});
-	assertModelExecutionOwner(owner);
-	const pricing = owner.pricing ?? benchmarkModelPricing(model);
+	}) : void 0;
+	if (owner) assertModelExecutionOwner(owner);
+	const pricing = owner?.pricing ?? benchmarkModelPricing(model);
 	const maxOutputTokens = positiveFlag(flags, "max-output-tokens", 16384);
 	const timeoutMs = positiveFlag(flags, "timeout-ms", 3e5);
 	return {
@@ -5234,9 +6103,11 @@ async function parseCommandConfig(argv, env, dependencies) {
 		revision: immutableRevision(requiredFlag(flags, "revision")),
 		split: requiredFlag(flags, "split"),
 		model: {
-			call: owner.call,
-			callRef: owner.callRef,
-			recordExecution: owner.recordExecution,
+			...owner ? {
+				call: owner.call,
+				callRef: owner.callRef,
+				recordExecution: owner.recordExecution
+			} : { callRef: `cli-bridge:${prime.bridgeUrl}` },
 			model,
 			maxOutputTokens,
 			timeoutMs,
@@ -5274,11 +6145,22 @@ async function parseCommandConfig(argv, env, dependencies) {
 		rlmSamples,
 		maxCostUsd,
 		maxArtifactBytes: positiveFlag(flags, "max-artifact-bytes", DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES),
-		modelOwnerModule,
+		...modelOwnerModule === void 0 ? {} : { modelOwnerModule },
+		...prime === void 0 ? {} : { prime },
 		command: `agent-eval analyst-benchmark ${argv.filter((argument) => argument !== "--resume").map(shellQuote).join(" ")}`,
 		resume: flags.has("resume")
 	};
 }
+/** Fail-loud narrowing: the dspy-rlm and direct analysts require an owner call path. */
+function requireModelOwnerSettings(model) {
+	const { call, recordExecution } = model;
+	if (typeof call !== "function" || typeof recordExecution !== "function") throw new Error("model-owner execution is required for the dspy-rlm and direct analysts");
+	return {
+		...model,
+		call,
+		recordExecution
+	};
+}
 function parseFlags(argv) {
 	const flags = /* @__PURE__ */ new Map();
 	for (let index = 0; index < argv.length; index += 1) {
@@ -5304,6 +6186,8 @@ const KNOWN_FLAGS = /* @__PURE__ */ new Set([
 	"resume",
 	"dataset",
 	"analyst",
+	"bridge-url",
+	"no-repair",
 	"labels",
 	"trace-dir",
 	"artifact-dir",
@@ -5339,7 +6223,7 @@ const KNOWN_FLAGS = /* @__PURE__ */ new Set([
 	"max-cost-usd",
 	"max-artifact-bytes"
 ]);
-const BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["resume"]);
+const BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["resume", "no-repair"]);
 function assertKnownFlags(flags) {
 	for (const flag of flags.keys()) if (!KNOWN_FLAGS.has(flag)) throw new Error(`unknown analyst-benchmark flag: --${flag}`);
 }
@@ -5467,6 +6351,6 @@ function shellQuote(value) {
 	return /^[a-zA-Z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
 }
 //#endregion
-export { normalizeAgentRxCategory as $, parseVerificationOutcome as A, analystBenchmarkDependencyLockDigest as B, MAX_INCORRECT_BLOCK_STEPS as C, DEFAULT_MAX_VERIFICATION_ARTIFACT_BYTES as D, publicBenchmarkSystemPrompt as E, ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256 as F, ANALYST_BENCHMARK_OBSERVATIONS_FILE as G, ANALYST_BENCHMARK_COST_LEDGER_FILE as H, ANALYST_BENCHMARK_EVIDENCE_PACKAGE_VERSION as I, summarizeAgentRxCalibration as J, AGENT_RX_UPSTREAM_REVISION as K, ANALYST_BENCHMARK_IMPLEMENTATION_DIGEST_ALGORITHM as L, ANALYST_BENCHMARK_DEPENDENCY_LOCK_FILES as M, ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256 as N, appendVerificationArtifactsToOtlp as O, ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256 as P, agentRxPredictionsToFindings as Q, ANALYST_BENCHMARK_IMPLEMENTATION_FILES as R, MAX_INCORRECT_BLOCKS as S, publicBenchmarkRlmInstructions as T, ANALYST_BENCHMARK_LOCAL_RECEIPT_FILE as U, analystBenchmarkImplementationDigest as V, ANALYST_BENCHMARK_MANIFEST_FILE as W, codeTracerPredictionsToFindings as X, codeTraceBenchCase as Y, agentRxBenchmarkCase as Z, compareAnalystRunners as _, preparePublicAnalystBenchmark as a, readAnalystInstructionsOverride as b, selectPublicBenchmarkRows as c, adaptPublicBenchmarkFindings as d, roundAgentRxStep as et, emptyPublicBenchmarkRunner as f, summarizeCodeTraceCalibration as g, renderCodeTraceCalibrationMarkdown as h, loadPublicBenchmarkRows as i, ANALYST_BENCHMARK_DEPENDENCY_LOCK_DIGEST_ALGORITHM as j, loadCodeTraceVerificationArtifacts as k, createPublicBenchmarkRlmRunner as l, readAnalystBenchmarkArtifact as m, runAnalystBenchmarkCommand as n, publicBenchmarkDistributions as o, expandCodeTraceFailureBlocks as p, renderAgentRxCalibrationMarkdown as q, renderAnalystBenchmarkMarkdown as r, publicBenchmarkSelectionReport as s, ANALYST_BENCHMARK_HELP as t, normalizeBenchmarkLabel as tt, createPublicBenchmarkDirectRunner as u, analystInstructionsOverrideFromText as v, publicBenchmarkProtocolSha256 as w, CODE_TRACE_BENCH_ANALYST_PROMPT as x, effectiveAnalystProtocolSha256 as y, ANALYST_BENCHMARK_IMPLEMENTATION_SHA256 as z };
+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 };
 
-//# sourceMappingURL=benchmark-command-CQPKRUr-.js.map
+//# sourceMappingURL=benchmark-command-CA_NFOmy.js.map