@tangle-network/agent-eval 0.144.6 → 0.144.8

package/dist/pre-registration-DakwTRXk.js

@@ -0,0 +1,96 @@
+//#region src/pre-registration.ts
+/**
+* Deterministic JSON canonicalization — sort object keys recursively.
+*
+* Two semantically-equal objects produce byte-identical canonicalized output;
+* this is what makes a content-hash stable across encoders, key insertion
+* orders, and runtime versions. Exported for any consumer that needs the same
+* canonicalization guarantee outside the manifest-signing path (e.g., signing
+* an artifact bundle, hashing a dataset version, etc.).
+*/
+function canonicalize(v) {
+	if (v === null || typeof v !== "object") return v;
+	if (Array.isArray(v)) return v.map(canonicalize);
+	const keys = Object.keys(v).sort();
+	const out = {};
+	for (const k of keys) out[k] = canonicalize(v[k]);
+	return out;
+}
+/**
+* SHA-256 hex (full 64 chars) over the canonicalized JSON encoding of `obj`.
+*
+* The same primitive `signManifest` and `verifyManifest` are built on, exposed
+* directly so consumers signing arbitrary structured content (artifact bundles,
+* production packets, dataset manifests, etc.) don't have to re-derive
+* canonicalize+sha256 from scratch.
+*
+* Stable across:
+*   - object key insertion order (canonicalization sorts keys recursively)
+*   - encoder choice (UTF-8 via TextEncoder, fixed)
+*   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)
+*
+* Named `hashJson` to disambiguate from `prompt-registry.ts`'s `hashContent`,
+* which takes a string input and returns a truncated 12-char prompt id.
+* Use `hashJson` when you mean "canonicalize then hash."
+*
+* @example
+*   const hash = await hashJson({ id: '1', kind: 'spec' })
+*   // 'a3f1...' (64 hex chars)
+*/
+async function hashJson(obj) {
+	const canonical = canonicalize(obj);
+	const bytes = new TextEncoder().encode(JSON.stringify(canonical));
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+	return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Sign a manifest with a SHA-256 content hash.
+*
+* The hash covers the canonicalized manifest with the `contentHash`
+* and `algo` fields stripped; this lets verifiers re-sign the rest and
+* compare. Returned manifest always carries `algo: 'sha256-content'`
+* so downstream consumers can identify the scheme; manifests without
+* `algo` still verify because it is stripped before hashing on both sides.
+*/
+async function signManifest(m) {
+	const hash = await hashJson(m);
+	return {
+		...m,
+		contentHash: hash,
+		algo: "sha256-content"
+	};
+}
+/**
+* Verify that a signed manifest has not been tampered with.
+*
+* Strips `contentHash` and `algo` before re-signing so manifests without
+* `algo` verify identically to ones that carry it.
+*/
+async function verifyManifest(m) {
+	const { contentHash, algo: _algo, ...rest } = m;
+	return (await signManifest(rest)).contentHash === contentHash;
+}
+/**
+* Evaluate a pre-registered hypothesis against observed results.
+* Mechanical — no re-interpretation permitted.
+*/
+async function evaluateHypothesis(manifest, observed) {
+	if (!await verifyManifest(manifest)) throw new Error("evaluateHypothesis: manifest content hash mismatch (tampered)");
+	const reasons = [];
+	if (!(manifest.direction === "increase" ? observed.effect > 0 : observed.effect < 0)) reasons.push("wrong_direction");
+	if (Math.abs(observed.effect) < manifest.minEffect) reasons.push("effect_too_small");
+	if (observed.pValue >= manifest.alpha) reasons.push("not_significant");
+	if (observed.n < manifest.preRegisteredN) reasons.push("undersampled");
+	return {
+		manifest,
+		observedN: observed.n,
+		observedEffect: observed.effect,
+		observedPValue: observed.pValue,
+		confirmed: reasons.length === 0,
+		rejectionReasons: reasons
+	};
+}
+//#endregion
+export { verifyManifest as a, signManifest as i, evaluateHypothesis as n, hashJson as r, canonicalize as t };
+
+//# sourceMappingURL=pre-registration-DakwTRXk.js.map

package/dist/pre-registration-DakwTRXk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pre-registration-DakwTRXk.js","names":[],"sources":["../src/pre-registration.ts"],"sourcesContent":["/**\n * Pre-registered hypotheses — declare what you're testing BEFORE the\n * run, check it AFTER. Prevents p-hacking, optional stopping, and the\n * \"we ran until it looked good\" failure mode.\n *\n * Manifest is a plain JSON-friendly object. Sign it with a content hash\n * + timestamp; the registered record becomes immutable. Post-run,\n * evaluate the manifest against observed results — the library refuses\n * to let you re-interpret a different metric as the declared one.\n */\n\nexport interface HypothesisManifest {\n  id: string\n  /** Human prose — goes into the audit trail. */\n  hypothesis: string\n  /** Metric the hypothesis claims to move. */\n  metric: string\n  /** 'increase' = candidate should score higher than baseline; 'decrease' = lower. */\n  direction: 'increase' | 'decrease'\n  /** Minimum effect size to count (same units as the metric). */\n  minEffect: number\n  /** Alpha threshold. */\n  alpha: number\n  /** Target statistical power at which sample size was pre-computed. */\n  power: number\n  /** Declared N per arm before running. */\n  preRegisteredN: number\n  /** ISO8601 timestamp the manifest was registered. */\n  registeredAt: string\n  /** Optional identifiers to tie into the trace corpus. */\n  baselineLabel?: string\n  candidateLabel?: string\n}\n\n/**\n * Identifier for the hashing scheme used to produce `contentHash`.\n *\n * `'sha256-content'` — sha256 hex over the canonicalized manifest with\n * the `contentHash` and `algo` fields stripped. Held as a string union\n * so future schemes can be added without breaking parsers; SignedManifest\n * values without `algo` deserialize cleanly because the field is optional.\n */\nexport type SignedManifestAlgo = 'sha256-content'\n\nexport interface SignedManifest extends HypothesisManifest {\n  /** sha256 hex of canonicalized manifest (everything except contentHash and algo). */\n  contentHash: string\n  /**\n   * Algorithm string describing how `contentHash` was produced.\n   *\n   * Optional on the type so serialized manifests without it still parse,\n   * but ALWAYS populated by {@link signManifest}. Consumers that want to\n   * enforce a known algorithm should reject manifests where this field\n   * is missing or unrecognized.\n   */\n  algo?: SignedManifestAlgo\n}\n\nexport interface HypothesisResult {\n  manifest: SignedManifest\n  observedN: number\n  observedEffect: number\n  observedPValue: number\n  /** True iff the observed effect hits the pre-declared direction with\n   *  magnitude ≥ minEffect AND p < alpha. */\n  confirmed: boolean\n  /** Enumerated reasons the hypothesis was rejected (each a machine-tag). */\n  rejectionReasons: Array<\n    'wrong_direction' | 'effect_too_small' | 'not_significant' | 'undersampled'\n  >\n  notes?: string\n}\n\n/**\n * Deterministic JSON canonicalization — sort object keys recursively.\n *\n * Two semantically-equal objects produce byte-identical canonicalized output;\n * this is what makes a content-hash stable across encoders, key insertion\n * orders, and runtime versions. Exported for any consumer that needs the same\n * canonicalization guarantee outside the manifest-signing path (e.g., signing\n * an artifact bundle, hashing a dataset version, etc.).\n */\nexport function canonicalize(v: unknown): unknown {\n  if (v === null || typeof v !== 'object') return v\n  if (Array.isArray(v)) return v.map(canonicalize)\n  const keys = Object.keys(v as Record<string, unknown>).sort()\n  const out: Record<string, unknown> = {}\n  for (const k of keys) out[k] = canonicalize((v as Record<string, unknown>)[k])\n  return out\n}\n\n/**\n * SHA-256 hex (full 64 chars) over the canonicalized JSON encoding of `obj`.\n *\n * The same primitive `signManifest` and `verifyManifest` are built on, exposed\n * directly so consumers signing arbitrary structured content (artifact bundles,\n * production packets, dataset manifests, etc.) don't have to re-derive\n * canonicalize+sha256 from scratch.\n *\n * Stable across:\n *   - object key insertion order (canonicalization sorts keys recursively)\n *   - encoder choice (UTF-8 via TextEncoder, fixed)\n *   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)\n *\n * Named `hashJson` to disambiguate from `prompt-registry.ts`'s `hashContent`,\n * which takes a string input and returns a truncated 12-char prompt id.\n * Use `hashJson` when you mean \"canonicalize then hash.\"\n *\n * @example\n *   const hash = await hashJson({ id: '1', kind: 'spec' })\n *   // 'a3f1...' (64 hex chars)\n */\nexport async function hashJson<T>(obj: T): Promise<string> {\n  const canonical = canonicalize(obj)\n  const bytes = new TextEncoder().encode(JSON.stringify(canonical))\n  const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes)\n  return Array.from(new Uint8Array(digest))\n    .map((b) => b.toString(16).padStart(2, '0'))\n    .join('')\n}\n\n/**\n * Sign a manifest with a SHA-256 content hash.\n *\n * The hash covers the canonicalized manifest with the `contentHash`\n * and `algo` fields stripped; this lets verifiers re-sign the rest and\n * compare. Returned manifest always carries `algo: 'sha256-content'`\n * so downstream consumers can identify the scheme; manifests without\n * `algo` still verify because it is stripped before hashing on both sides.\n */\nexport async function signManifest(m: HypothesisManifest): Promise<SignedManifest> {\n  const hash = await hashJson(m)\n  return { ...m, contentHash: hash, algo: 'sha256-content' }\n}\n\n/**\n * Verify that a signed manifest has not been tampered with.\n *\n * Strips `contentHash` and `algo` before re-signing so manifests without\n * `algo` verify identically to ones that carry it.\n */\nexport async function verifyManifest(m: SignedManifest): Promise<boolean> {\n  const { contentHash, algo: _algo, ...rest } = m\n  void _algo\n  const resigned = await signManifest(rest)\n  return resigned.contentHash === contentHash\n}\n\n/**\n * Evaluate a pre-registered hypothesis against observed results.\n * Mechanical — no re-interpretation permitted.\n */\nexport async function evaluateHypothesis(\n  manifest: SignedManifest,\n  observed: { n: number; effect: number; pValue: number },\n): Promise<HypothesisResult> {\n  if (!(await verifyManifest(manifest))) {\n    throw new Error('evaluateHypothesis: manifest content hash mismatch (tampered)')\n  }\n  const reasons: HypothesisResult['rejectionReasons'] = []\n  const directionOk = manifest.direction === 'increase' ? observed.effect > 0 : observed.effect < 0\n  if (!directionOk) reasons.push('wrong_direction')\n  if (Math.abs(observed.effect) < manifest.minEffect) reasons.push('effect_too_small')\n  if (observed.pValue >= manifest.alpha) reasons.push('not_significant')\n  if (observed.n < manifest.preRegisteredN) reasons.push('undersampled')\n  return {\n    manifest,\n    observedN: observed.n,\n    observedEffect: observed.effect,\n    observedPValue: observed.pValue,\n    confirmed: reasons.length === 0,\n    rejectionReasons: reasons,\n  }\n}\n"],"mappings":";;;;;;;;;;AAkFA,SAAgB,aAAa,GAAqB;CAChD,IAAI,MAAM,QAAQ,OAAO,MAAM,UAAU,OAAO;CAChD,IAAI,MAAM,QAAQ,CAAC,GAAG,OAAO,EAAE,IAAI,YAAY;CAC/C,MAAM,OAAO,OAAO,KAAK,CAA4B,CAAC,CAAC,KAAK;CAC5D,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,KAAK,MAAM,IAAI,KAAK,aAAc,EAA8B,EAAE;CAC7E,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;AAuBA,eAAsB,SAAY,KAAyB;CACzD,MAAM,YAAY,aAAa,GAAG;CAClC,MAAM,QAAQ,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,UAAU,SAAS,CAAC;CAChE,MAAM,SAAS,MAAM,WAAW,OAAO,OAAO,OAAO,WAAW,KAAK;CACrE,OAAO,MAAM,KAAK,IAAI,WAAW,MAAM,CAAC,CAAC,CACtC,KAAK,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CAC3C,KAAK,EAAE;AACZ;;;;;;;;;;AAWA,eAAsB,aAAa,GAAgD;CACjF,MAAM,OAAO,MAAM,SAAS,CAAC;CAC7B,OAAO;EAAE,GAAG;EAAG,aAAa;EAAM,MAAM;CAAiB;AAC3D;;;;;;;AAQA,eAAsB,eAAe,GAAqC;CACxE,MAAM,EAAE,aAAa,MAAM,OAAO,GAAG,SAAS;CAG9C,QAAO,MADgB,aAAa,IAAI,EAAA,CACxB,gBAAgB;AAClC;;;;;AAMA,eAAsB,mBACpB,UACA,UAC2B;CAC3B,IAAI,CAAE,MAAM,eAAe,QAAQ,GACjC,MAAM,IAAI,MAAM,+DAA+D;CAEjF,MAAM,UAAgD,CAAC;CAEvD,IAAI,EADgB,SAAS,cAAc,aAAa,SAAS,SAAS,IAAI,SAAS,SAAS,IAC9E,QAAQ,KAAK,iBAAiB;CAChD,IAAI,KAAK,IAAI,SAAS,MAAM,IAAI,SAAS,WAAW,QAAQ,KAAK,kBAAkB;CACnF,IAAI,SAAS,UAAU,SAAS,OAAO,QAAQ,KAAK,iBAAiB;CACrE,IAAI,SAAS,IAAI,SAAS,gBAAgB,QAAQ,KAAK,cAAc;CACrE,OAAO;EACL;EACA,WAAW,SAAS;EACpB,gBAAgB,SAAS;EACzB,gBAAgB,SAAS;EACzB,WAAW,QAAQ,WAAW;EAC9B,kBAAkB;CACpB;AACF"}

package/dist/prime-bridge-transport-6feEglLf.d.ts

@@ -0,0 +1,49 @@
+//#region src/analyst/prime-bridge-transport.d.ts
+/**
+ * The bridge seam for the prime analyst protocol: one POST to an
+ * OpenAI-compatible `/v1/chat/completions` endpoint, returning the raw status
+ * and body text.
+ *
+ * Deliberately NOT `callLlm` from `../llm-client`, which serves a different
+ * contract:
+ *  - it retries transient failures, and a prime turn holds a single model seat
+ *    for minutes — a silent second attempt doubles the seat time and the spend;
+ *  - it normalizes usage, while the protocol's receipt depends on the bridge's
+ *    non-standard `model_requests` and `estimated` fields;
+ *  - it composes sampling and response-format options the bridge's CLI backends
+ *    reject;
+ *  - it collapses HTTP status, unparseable body, and empty content into two
+ *    error classes, while the protocol classifies them as three distinct
+ *    terminal reasons.
+ */
+interface PrimeBridgeTransportRequest {
+  url: string;
+  body: {
+    model: string;
+    messages: Array<{
+      role: 'user';
+      content: string;
+    }>;
+  };
+  /**
+   * The call's only deadline. The protocol aborts it on the per-call timeout
+   * and on the caller's cancellation, so a transport that imposes a second
+   * deadline of its own competes with this one.
+   */
+  signal: AbortSignal;
+}
+interface PrimeBridgeTransportResult {
+  status: number;
+  text: string;
+}
+/** One POST to the bridge. Injectable so tests run against a fake bridge. */
+type PrimeBridgeTransport = (request: PrimeBridgeTransportRequest) => Promise<PrimeBridgeTransportResult>;
+/**
+ * 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.
+ */
+declare function nodeHttpPrimeBridgeTransport(): PrimeBridgeTransport;
+//#endregion
+export { nodeHttpPrimeBridgeTransport as i, PrimeBridgeTransportRequest as n, PrimeBridgeTransportResult as r, PrimeBridgeTransport as t };
+//# sourceMappingURL=prime-bridge-transport-6feEglLf.d.ts.map

package/dist/prime-bridge-transport-6feEglLf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prime-bridge-transport-6feEglLf.d.ts","names":[],"sources":["../src/analyst/prime-bridge-transport.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAoBiB;EACf;EACA;IACE;IACA,UAAU;MAAQ;MAAc;;;;;;;;EAOlC,QAAQ;;UAGO;EACf;EACA;;;KAIU,wBACV,SAAS,gCACN,QAAQ;;;;;;iBAOG,gCAAgC"}

package/dist/prime-protocol-BfSalTfR.js

@@ -0,0 +1,453 @@
+import { c as ValidationError } from "./errors-D-LKuDhb.js";
+import { createHash } from "node:crypto";
+//#region src/analyst/equal-terms.ts
+/**
+* Refuses a comparison whose arms are not on equal terms: an empty set, a
+* duplicated id, or unequal repair turns — a retry is a second sample the
+* other arms never got. `noun` names the arm kind in every message so a
+* refusal reads in the caller's vocabulary.
+*/
+function assertEqualDeclarativeTerms(noun, terms) {
+	if (terms.length === 0) throw new ValidationError(`a ${noun} comparison needs at least one ${noun}`);
+	const ids = terms.map((term) => term.id);
+	const duplicate = ids.find((id, index) => ids.indexOf(id) !== index);
+	if (duplicate !== void 0) throw new ValidationError(`${noun} '${duplicate}' is declared twice`);
+	const repairTurns = terms[0].repairTurns;
+	const unequal = terms.find((term) => term.repairTurns !== repairTurns);
+	if (unequal) throw new ValidationError(`${noun} '${unequal.id}' gets ${unequal.repairTurns} bounded repair turns and ${noun} '${terms[0].id}' gets ${repairTurns}; a retry is a second sample the other arms never got`);
+	return {
+		ids,
+		repairTurns
+	};
+}
+//#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
+export { extractPrimeJsonObject as a, primeProtocolSha256 as c, runPrimeExchange as d, assertEqualDeclarativeTerms as f, emptyPrimeRawUsage as i, primeReplyDefect as l, buildPrimePrompt as n, mergePrimeRawUsage as o, buildPrimeRepairPrompt as r, normalizePrimeUsage as s, analystUsageReceiptFromPrimeUsage as t, projectPrimeTrajectory as u };
+
+//# sourceMappingURL=prime-protocol-BfSalTfR.js.map