@tangle-network/agent-eval 0.200.1 → 0.202.0

package/dist/{campaign-L391bmir.js → campaign-XXmOU0R0.js}

@@ -1,27 +1,28 @@
 import { s as ValidationError, t as AgentEvalError } from "./errors-Dngq5h35.js";
-import { i as compareCodeUnits } from "./canonical-BsZVgBhW.js";
-import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-DZMW8cuF.js";
+import { a as hashCanonical, i as compareCodeUnits, r as canonicalString } from "./canonical-BsZVgBhW.js";
+import { c as agentProfileId, d as harnessAxisOf, i as verifyCompletion, l as agentProfileModelId, s as agentProfileHash, t as extractProducedState } from "./produced-state-CR2tAPLf.js";
 import { s as buildAgentProfileCell } from "./agent-profile-cell-DcFW4vOc.js";
-import { r as pairedBootstrap } from "./paired-tests-C8iCsioC.js";
-import { t as comparePairedArms } from "./paired-arms-DKZFVPt8.js";
-import { o as pairHoldout } from "./statistical-heldout-BAFDCo07.js";
+import { r as pairedBootstrap } from "./paired-tests-Ccr16gcW.js";
+import { t as comparePairedArms } from "./paired-arms-DpS_h8ON.js";
+import { o as pairHoldout } from "./statistical-heldout-CNLOvRq_.js";
 import { c as runTaskScore, i as modelHasSnapshot, n as UNKNOWN_MODEL, u as validateRunRecord } from "./run-record-BRlM99rX.js";
 import { n as contentHash, t as canonicalJson } from "./verdict-cache-BQEsVy9n.js";
-import { at as resolveRunDir, d as combineComparisonCosts, it as planCampaignRun, lt as cellCachePath, rt as runCampaign, u as executeOptimizationMethod, ut as computeManifestHash, v as labelTrustRank } from "./llm-judge-CL6f3utD.js";
-import { n as campaignCellToRunRecord, r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-tNnlQIrD.js";
+import { at as resolveRunDir, d as combineComparisonCosts, it as planCampaignRun, lt as cellCachePath, rt as runCampaign, u as executeOptimizationMethod, ut as computeManifestHash, v as labelTrustRank } from "./llm-judge-C-0P1WiT.js";
+import { n as campaignCellToRunRecord, r as projectCampaignCellQuality, t as campaignCellCostProvenance } from "./run-record-BB290Y9A.js";
 import { t as CostAccountingIncompleteError } from "./cost-ledger-_IbkejCF.js";
-import { B as assertRealBackend, F as surfaceContentHash, H as assertCampaignDesign, K as campaignScenarioIdentity, V as summarizeBackendIntegrity, j as assertCodeSurfaceIdentity } from "./campaign-evidence-jL_U7Ikv.js";
+import { B as assertRealBackend, F as surfaceContentHash, H as assertCampaignDesign, K as campaignScenarioIdentity, V as summarizeBackendIntegrity, j as assertCodeSurfaceIdentity } from "./campaign-evidence-Dt_rWPk2.js";
 import { m as mapConcurrent } from "./journal-DvKCvjty.js";
-import { S as fsCampaignStorage } from "./external-optimizer-subprocess-laM1-UDV.js";
-import "./search-kernel-AVgIjXaI.js";
-import "./search-ledger-CL0-mXQ8.js";
-import "./search-summary-DvWk0hb3.js";
-import { a as scoreAnalystFindings } from "./benchmark-BeQJyrRC.js";
-import "./external-optimizer-process-CEXcCKqd.js";
-import "./skillopt-optimization-method-B2syNik0.js";
-import "./sequential-Yz3OSskl.js";
+import { S as fsCampaignStorage } from "./external-optimizer-subprocess-CkyUUV7h.js";
+import "./search-kernel-Dpniloks.js";
+import "./search-ledger-CXQPwdWz.js";
+import "./search-summary-C1nAHgkB.js";
+import { a as scoreAnalystFindings } from "./benchmark-BywPeAUo.js";
+import "./external-optimizer-process-KLcw0Vnc.js";
+import "./skillopt-optimization-method-Bls9t-G_.js";
+import "./sequential-DWn_np6P.js";
 import { createHash } from "node:crypto";
 import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { z } from "zod";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { devNull, tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
@@ -1298,8 +1299,10 @@ function sha256$1(input) {
 	return createHash("sha256").update(input).digest("hex").slice(0, 16);
 }
 function appendLine(path, line) {
-	if (existsSync(path)) writeFileSync(path, readFileSync(path, "utf8") + line);
-	else writeFileSync(path, line);
+	if (existsSync(path)) {
+		const existing = readFileSync(path, "utf8");
+		writeFileSync(path, existing + line);
+	} else writeFileSync(path, line);
 }
 //#endregion
 //#region src/campaign/neutralize.ts
@@ -1447,10 +1450,11 @@ function sequentialOptimizationMethod(options) {
 */
 function makePlaybackDispatch(driver) {
 	return async (profile, scenario, ctx) => {
-		return extractProducedState(await driver.run(scenario, {
+		const events = await driver.run(scenario, {
 			...ctx,
 			profile
-		}));
+		});
+		return extractProducedState(events);
 	};
 }
 /**
@@ -1675,7 +1679,8 @@ function buildRunRecord(args) {
 	const { cell, profile, profileHash, configHash, experimentId, splitTag, commitSha, matrixId } = args;
 	const profileId = agentProfileId(profile);
 	const model = recordModel(cell, profileId, agentProfileModelId(profile));
-	const record = campaignCellToRunRecord(durableCellForRecord(cell), {
+	const durableCell = durableCellForRecord(cell);
+	const record = campaignCellToRunRecord(durableCell, {
 		runId: `${matrixId}:${profileId}:${cell.cellId}`,
 		experimentId,
 		candidateId: profileId,
@@ -1964,7 +1969,7 @@ function createProfileMatrixPlan(opts) {
 		scenarios: scenarios.map((scenario) => scenario.id)
 	}).slice(0, 16)}`;
 	if (experimentId.trim().length === 0) throw new SegmentedProfileMatrixError("experimentId must be non-empty");
-	const planDigest = `sha256:${contentHash({
+	const identityMaterial = {
 		schema: "tangle.profile-matrix-plan.v1",
 		profiles: profiles.map((profile, index) => ({
 			ordinal: index,
@@ -1995,7 +2000,8 @@ function createProfileMatrixPlan(opts) {
 		validate,
 		personaOf: opts.personaOf?.toString() ?? null,
 		corpusText: opts.corpusText?.toString() ?? null
-	})}`;
+	};
+	const planDigest = `sha256:${contentHash(identityMaterial)}`;
 	const matrixId = `pmx_${planDigest.slice(7, 31)}`;
 	const rows = [];
 	const seenCellIds = /* @__PURE__ */ new Set();
@@ -2361,6 +2367,238 @@ function byteLength(value) {
 	return new TextEncoder().encode(value).byteLength;
 }
 //#endregion
+//#region src/campaign/retained-dispatch.ts
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const headerSchema = z.object({
+	kind: z.literal("retained-dispatch-v1"),
+	scope: digest,
+	limits: z.array(z.tuple([z.string().min(1), z.number().int().nonnegative()]))
+}).strict();
+const eventSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("started"),
+	id: digest,
+	lane: z.string().min(1)
+}).strict(), z.object({
+	kind: z.literal("settled"),
+	id: digest,
+	receipt: digest
+}).strict()]);
+const resultSchema = z.object({
+	kind: z.literal("retained-dispatch-result-v1"),
+	id: digest,
+	receipt: digest,
+	value: z.unknown()
+}).strict();
+/**
+* Persist dispatch intent before an external call and its validated result afterward.
+* Replays settled calls; never repeats an uncertain call or refunds its allowance.
+* This wraps a campaign's dispatch; runEval still owns scheduling, judging and reports.
+* Uses CampaignStorage's existing compare-and-append, not another database or scheduler.
+*/
+function createRetainedDispatch(options) {
+	if (!options.runDir.trim()) throw new ValidationError("retained dispatch requires a run directory");
+	const storage = options.storage ?? fsCampaignStorage();
+	const parse = options.parse;
+	const header = headerSchema.parse({
+		kind: "retained-dispatch-v1",
+		scope: hashCanonical(options.scope),
+		limits: Object.entries(options.limits).sort(([a], [b]) => compareCodeUnits(a, b))
+	});
+	if (!header.limits.length) throw new ValidationError("retained dispatch requires named allowances");
+	const limits = new Map(header.limits);
+	const counts = /* @__PURE__ */ new Map();
+	const calls = /* @__PURE__ */ new Map();
+	const active = /* @__PURE__ */ new Map();
+	const indexPath = join(options.runDir, "dispatches.jsonl");
+	const receiptsDir = join(options.runDir, "dispatch-results");
+	const resultPath = (id) => join(receiptsDir, `${id.slice(7)}.json`);
+	storage.ensureDir(options.runDir);
+	storage.ensureDir(receiptsDir);
+	let retainedText = "";
+	let revision = 0;
+	let opened = false;
+	const fail = (message) => {
+		throw new ValidationError(`retained dispatch: ${message}`);
+	};
+	const apply = (event) => {
+		const existing = calls.get(event.id);
+		if (event.kind === "started") {
+			const limit = limits.get(event.lane);
+			const count = counts.get(event.lane) ?? 0;
+			if (existing || limit === void 0 || count >= limit) fail("invalid or over-budget dispatch history");
+			calls.set(event.id, { lane: event.lane });
+			counts.set(event.lane, count + 1);
+		} else {
+			if (!existing || existing.receipt) return fail("settlement has no unique pending dispatch");
+			existing.receipt = event.receipt;
+		}
+	};
+	const refresh = () => {
+		const stored = storage.read(indexPath);
+		if (stored === void 0 && storage.exists(indexPath)) fail("cannot read existing history");
+		const text = stored ?? "";
+		if (!text.startsWith(retainedText) || text && !text.endsWith("\n")) fail("history was truncated, replaced or torn");
+		for (const line of text.slice(retainedText.length).split("\n").filter(Boolean)) {
+			const value = JSON.parse(line);
+			if (!opened) {
+				if (hashCanonical(headerSchema.parse(value)) !== hashCanonical(header)) fail("resume changed its scope or allowances");
+				opened = true;
+			} else apply(eventSchema.parse(value));
+		}
+		retainedText = text;
+		revision = Buffer.byteLength(text);
+	};
+	const append = (event) => {
+		const line = `${canonicalString(event)}\n`;
+		const next = storage.append(indexPath, line, revision);
+		if (next === void 0) {
+			refresh();
+			return false;
+		}
+		if (next !== revision + Buffer.byteLength(line)) fail("storage returned an invalid append revision");
+		retainedText += line;
+		revision = next;
+		if (event.kind === "retained-dispatch-v1") opened = true;
+		else apply(event);
+		return true;
+	};
+	refresh();
+	if (!opened && !append(header) && !opened) fail("history is busy; retry with the same run directory");
+	const readResult = (id) => {
+		const content = storage.read(resultPath(id));
+		if (content === void 0) return void 0;
+		const result = resultSchema.parse(JSON.parse(content));
+		if (result.id !== id) return fail("retained result dispatch id mismatch");
+		if (hashCanonical(result.value) !== result.receipt) return fail("retained result digest mismatch");
+		return {
+			value: parse(result.value),
+			receipt: result.receipt
+		};
+	};
+	const settle = (id, receipt) => {
+		while (true) {
+			const existing = calls.get(id);
+			if (existing?.receipt) {
+				if (existing.receipt !== receipt) fail("settled result digest mismatch");
+				return;
+			}
+			if (!existing) fail("settlement has no pending dispatch");
+			const previousRevision = revision;
+			if (append({
+				kind: "settled",
+				id,
+				receipt
+			})) return;
+			if (revision === previousRevision) fail("settlement is busy; retained result awaits reconciliation");
+		}
+	};
+	const load = (id, receipt) => {
+		const result = readResult(id);
+		if (!result) return fail("settled result is missing");
+		if (result.receipt !== receipt) return fail("settled result digest mismatch");
+		return {
+			succeeded: true,
+			value: result.value,
+			dispatchId: id,
+			receiptDigest: receipt,
+			replayed: true
+		};
+	};
+	return {
+		/** The input binds all behavior-affecting request material, not just a caller-selected nonce. */
+		run(request) {
+			const id = hashCanonical([
+				header.scope,
+				request.lane,
+				request.input
+			]);
+			const pending = active.get(id);
+			if (pending) return pending;
+			const work = async () => {
+				if (!limits.has(request.lane)) return fail("unknown allowance lane");
+				if (calls.has(id) && !calls.get(id).receipt) refresh();
+				while (true) {
+					const existing = calls.get(id);
+					if (existing) {
+						if (existing.receipt) return load(id, existing.receipt);
+						const result = readResult(id);
+						if (!result) return {
+							succeeded: false,
+							reason: "outcome_unknown",
+							dispatchId: id
+						};
+						settle(id, result.receipt);
+						return {
+							succeeded: true,
+							value: result.value,
+							dispatchId: id,
+							receiptDigest: result.receipt,
+							replayed: true
+						};
+					}
+					request.signal?.throwIfAborted();
+					if ((counts.get(request.lane) ?? 0) >= limits.get(request.lane)) return {
+						succeeded: false,
+						reason: "allowance_exhausted",
+						dispatchId: id
+					};
+					const previousRevision = revision;
+					if (append({
+						kind: "started",
+						id,
+						lane: request.lane
+					})) break;
+					if (revision === previousRevision) return fail("history is busy; retry with the same input");
+				}
+				let value;
+				try {
+					request.signal?.throwIfAborted();
+					value = parse(await request.dispatch());
+				} catch (error) {
+					return {
+						succeeded: false,
+						reason: "outcome_unknown",
+						dispatchId: id,
+						diagnostic: error instanceof Error ? error.message : String(error)
+					};
+				}
+				const encoded = canonicalString(value);
+				const decoded = JSON.parse(encoded);
+				const retainedValue = parse(decoded);
+				if (canonicalString(retainedValue) !== encoded) return fail("result decoder is not stable across serialization");
+				const receipt = hashCanonical(decoded);
+				const retainedResult = canonicalString({
+					kind: "retained-dispatch-result-v1",
+					id,
+					receipt,
+					value: decoded
+				});
+				const file = resultPath(id);
+				if (storage.append(file, retainedResult, 0) === void 0 && storage.read(file) !== retainedResult) fail("cannot retain dispatch result");
+				settle(id, receipt);
+				return {
+					succeeded: true,
+					value: retainedValue,
+					dispatchId: id,
+					receiptDigest: receipt,
+					replayed: false
+				};
+			};
+			const promise = work();
+			active.set(id, promise);
+			promise.finally(() => {
+				active.delete(id);
+			}).catch(() => {});
+			return promise;
+		},
+		/** Counts include uncertain dispatches, which keep their reservation. No pricing is inferred. */
+		committed() {
+			refresh();
+			return new Map(header.limits.map(([lane]) => [lane, counts.get(lane) ?? 0]));
+		}
+	};
+}
+//#endregion
 //#region src/campaign/scenario-selection.ts
 const DEFAULT_SATURATION_CEILING = .999;
 /** Variance below this is treated as "every candidate scored the same". */
@@ -2577,8 +2815,8 @@ async function abortableEvaluation(signal, execute) {
 * adapter can slot in without touching proposer code. Only the git adapter
 * ships today. See `docs/design/loop-taxonomy.md`.
 */
-const MAX_GIT_OUTPUT_BYTES = 256 * 1024 * 1024;
-const FILE_HASH_CHUNK_BYTES = 1024 * 1024;
+const MAX_GIT_OUTPUT_BYTES = 268435456;
+const FILE_HASH_CHUNK_BYTES = 1048576;
 const GIT_REPOSITORY_ENV = /* @__PURE__ */ new Set([
 	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
 	"GIT_COMMON_DIR",
@@ -3086,6 +3324,6 @@ function resolveWorktreePath(surface, worktreeDir) {
 	return verifyCodeSurface(surface, worktreeDir).path;
 }
 //#endregion
-export { planEvalFixtureRun as A, LabeledScenarioStoreError as C, discoverEvalFixtures as D, neutralizationGate as E, buildTraceAnalystSurfaceDispatch as M, traceAnalystQualityJudge as N, loadEvalFixture as O, FsLabeledScenarioStore as S, rolloutArgumentDiff as T, scoreboardSummary as _, autoevalsScorerJudge as a, sequentialOptimizationMethod as b, selectDiscriminative as c, runProfileMatrixSegment as d, ProfileMatrixError as f, scoreUserStory as g, renderScoreboardMarkdown as h, verifyCodeSurface as i, analyzeCrossSurfaceInteractions as j, loadEvalFixtureScenarios as k, createProfileMatrixPlan as l, makePlaybackDispatch as m, gitWorktreeAdapter as n, phoenixEvaluatorJudge as o, runProfileMatrix as p, resolveWorktreePath as r, scoreDiscrimination as s, WorktreeAdapterError as t, finalizeProfileMatrix as u, userStoryScoreboard as v, classifyUngroundedLiterals as w, neutralizeText as x, scopedOptimizationMethod as y };
+export { loadEvalFixtureScenarios as A, FsLabeledScenarioStore as C, neutralizationGate as D, rolloutArgumentDiff as E, analyzeCrossSurfaceInteractions as M, buildTraceAnalystSurfaceDispatch as N, discoverEvalFixtures as O, traceAnalystQualityJudge as P, neutralizeText as S, classifyUngroundedLiterals as T, scoreUserStory as _, autoevalsScorerJudge as a, scopedOptimizationMethod as b, selectDiscriminative as c, finalizeProfileMatrix as d, runProfileMatrixSegment as f, renderScoreboardMarkdown as g, makePlaybackDispatch as h, verifyCodeSurface as i, planEvalFixtureRun as j, loadEvalFixture as k, createRetainedDispatch as l, runProfileMatrix as m, gitWorktreeAdapter as n, phoenixEvaluatorJudge as o, ProfileMatrixError as p, resolveWorktreePath as r, scoreDiscrimination as s, WorktreeAdapterError as t, createProfileMatrixPlan as u, scoreboardSummary as v, LabeledScenarioStoreError as w, sequentialOptimizationMethod as x, userStoryScoreboard as y };
 
-//# sourceMappingURL=campaign-L391bmir.js.map
+//# sourceMappingURL=campaign-XXmOU0R0.js.map