@tangle-network/agent-eval 0.215.0 → 0.216.0

package/dist/{external-optimizer-subprocess-CA3aXT8I.js → external-optimizer-subprocess-DcerlZSG.js}

@@ -1,9 +1,11 @@
 import { t as canonicalJson } from "./verdict-cache-BQEsVy9n.js";
-import { c as costForTokenPricing, i as CostLedger } from "./cost-ledger-DFOeLeJi.js";
+import { c as costForTokenPricing, i as CostLedger } from "./cost-ledger-D2FnJPBF.js";
 import { n as appendSearchLedgerLine, r as tryWithSearchLedgerFileLock } from "./search-ledger-file-BqOo-bVo.js";
-import { f as ModelSubstitutionError, g as assertServedModelPolicy, h as assertServedModel } from "./llm-client-C_o62yG1.js";
+import { n as ANALYST_SEVERITIES, r as FINDING_SCOPE_FIELDS } from "./types-IXD2HJzu.js";
+import { f as ModelSubstitutionError, g as assertServedModelPolicy, h as assertServedModel } from "./llm-client-DQveoxSM.js";
 import { createRequire } from "node:module";
 import { randomBytes } from "node:crypto";
+import { z } from "zod";
 import { isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { spawn } from "node:child_process";
@@ -112,6 +114,263 @@ function createRunCostLedger(input) {
 	});
 }
 //#endregion
+//#region src/analyst/finding-scope.ts
+/**
+* What a finding is about and what it was measured on — AnalystFinding 1.1.0.
+*
+* A 1.0.0 finding states a claim with no layer and no population, so "a flat
+* team beat a deep hierarchy", measured on 4 runs of one play where run 2
+* inherited run 1's code, reads exactly like a lab-wide rule. Schema 1.1.0
+* makes the population part of the record:
+*
+*   - `layer` names the level the claim is about, on one ladder from a single
+*     event up to the whole lab, plus `meta` for findings about the measurement
+*     itself (a judge, a ruler, an analyst).
+*   - `scope` names the measured population, its size and time window, and the
+*     domain path it was drawn from.
+*   - `method` says whether the claim was computed, measured or judged; a
+*     judged claim without calibration reads as uncalibrated.
+*   - `evidence_units` lists the measured units with their lineage. When it is
+*     present the stored `scope.n` and `scope.population` must equal it, so the
+*     declared population cannot drift from the evidence.
+*
+* A claim moves above the layer it was measured at only through `promote`.
+*/
+/**
+* The layer ladder, lowest first. `problem` is what discovery-lab calls a
+* theatre. `meta` sits outside the ladder: it is about the instrument, not the
+* agents, so it never promotes and never bounds another layer.
+*/
+const FINDING_LAYERS = [
+	"event",
+	"turn",
+	"agent",
+	"team",
+	"run",
+	"play",
+	"problem",
+	"domain",
+	"lab",
+	"meta"
+];
+/** Rank on the ladder; `meta` has none. */
+function findingLayerRank(layer) {
+	return layer === "meta" ? null : FINDING_LAYERS.indexOf(layer);
+}
+const nonEmpty = z.string().refine((value) => value.trim().length > 0, { message: "must be a non-empty string" });
+const timestamp = z.string().refine((value) => Number.isFinite(Date.parse(value)), { message: "must be a valid timestamp" });
+const finite = z.number().refine(Number.isFinite, { message: "must be finite" });
+const unitRate = finite.refine((value) => value >= 0 && value <= 1, { message: "must be in [0,1]" });
+const layerSchema = z.enum(FINDING_LAYERS);
+const scopeSchema = z.object({
+	population: z.array(nonEmpty),
+	n: z.number().int().nonnegative(),
+	window: z.object({
+		from: timestamp,
+		to: timestamp
+	}).strict(),
+	domain_path: z.array(nonEmpty).min(1).optional()
+}).strict();
+const methodSchema = z.object({
+	kind: z.enum([
+		"computed",
+		"measured",
+		"judged"
+	]),
+	name: nonEmpty,
+	version: nonEmpty,
+	calibration: z.object({
+		gold_n: z.number().int().positive(),
+		agreement: unitRate,
+		kappa: finite.refine((value) => value >= -1 && value <= 1, { message: "must be in [-1,1]" })
+	}).strict().optional()
+}).strict();
+const measureSchema = z.object({
+	name: nonEmpty,
+	value: finite,
+	unit: z.string(),
+	interval: z.tuple([finite, finite]).optional(),
+	level: finite.refine((value) => value > 0 && value < 1, { message: "must be in (0,1)" }).optional()
+}).strict();
+const evidenceUnitSchema = z.object({
+	id: nonEmpty,
+	layer: layerSchema,
+	derived_from: nonEmpty.nullable().optional()
+}).strict();
+const findingObject = z.object({
+	schema_version: z.enum(["1.0.0", "1.1.0"]),
+	finding_id: nonEmpty,
+	analyst_id: nonEmpty,
+	produced_at: timestamp,
+	severity: z.enum(ANALYST_SEVERITIES),
+	area: nonEmpty,
+	claim: nonEmpty,
+	rationale: z.string().optional(),
+	evidence_refs: z.array(z.object({
+		kind: z.enum([
+			"span",
+			"event",
+			"artifact",
+			"finding",
+			"metric"
+		]),
+		uri: nonEmpty,
+		excerpt: z.string().optional()
+	}).strict()),
+	recommended_action: z.string().optional(),
+	validation_plan: z.string().optional(),
+	confidence: unitRate,
+	subject: z.string().optional(),
+	derived_from_judge: z.boolean().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	layer: layerSchema.optional(),
+	scope: scopeSchema.optional(),
+	method: methodSchema.optional(),
+	measure: measureSchema.optional(),
+	confounders: z.array(nonEmpty).optional(),
+	valid_for: nonEmpty.optional(),
+	claim_id: nonEmpty.optional(),
+	evidence_units: z.array(evidenceUnitSchema).min(1).optional()
+}).strict();
+function checkFinding(finding, context) {
+	const issue = (path, message) => context.addIssue({
+		code: "custom",
+		path,
+		message
+	});
+	if (finding.schema_version === "1.0.0") {
+		for (const field of FINDING_SCOPE_FIELDS) if (finding[field] !== void 0) issue([field], `${field} requires schema_version 1.1.0`);
+		return;
+	}
+	if (finding.layer === void 0) issue(["layer"], "1.1.0 findings require a layer");
+	if (finding.scope === void 0) issue(["scope"], "1.1.0 findings require a scope");
+	if (finding.method === void 0) issue(["method"], "1.1.0 findings require a method");
+	const { scope, measure, evidence_units: units } = finding;
+	if (scope) {
+		if (Date.parse(scope.window.from) > Date.parse(scope.window.to)) issue(["scope", "window"], "window.from must not be after window.to");
+		if (new Set(scope.population).size !== scope.population.length) issue(["scope", "population"], "population ids must be unique");
+		if (scope.population.length > 0 && scope.population.length !== scope.n) issue(["scope", "n"], `n ${scope.n} does not match ${scope.population.length} population ids`);
+	}
+	if (measure?.interval && measure.interval[0] > measure.interval[1]) issue(["measure", "interval"], "interval lower bound exceeds its upper bound");
+	if (measure?.level !== void 0 && measure.interval === void 0) issue(["measure", "level"], "level describes an interval; none is present");
+	if (finding.method?.kind !== "judged" && finding.method?.calibration !== void 0) issue(["method", "calibration"], "only judged findings carry a calibration");
+	if (!units) return;
+	const ids = units.map((unit) => unit.id);
+	if (new Set(ids).size !== ids.length) issue(["evidence_units"], "unit ids must be unique");
+	if (scope) {
+		if (scope.n !== ids.length) issue(["scope", "n"], `n ${scope.n} does not match ${ids.length} evidence units`);
+		const population = [...scope.population].sort();
+		const unitIds = [...ids].sort();
+		if (population.length !== unitIds.length || population.some((id, index) => id !== unitIds[index])) issue(["scope", "population"], "population must name exactly the evidence units");
+	}
+	const findingRank = finding.layer === void 0 ? null : findingLayerRank(finding.layer);
+	if (findingRank === null) return;
+	for (const [index, unit] of units.entries()) {
+		const unitRank = findingLayerRank(unit.layer);
+		if (unitRank !== null && unitRank > findingRank) issue([
+			"evidence_units",
+			index,
+			"layer"
+		], `a ${finding.layer} finding cannot rest on a ${unit.layer} unit`);
+	}
+}
+/** The one validator for stored findings of either schema version. Unknown fields fail. */
+const AnalystFindingSchema = findingObject.superRefine(checkFinding);
+/** A finding admitted as candidate-generation input; same rules plus its origin. */
+const ProposalFindingSchema = findingObject.extend({ proposal_origin: z.enum(["search", "production"]) }).strict().superRefine(checkFinding);
+/** Validate one stored finding of schema 1.0.0 or 1.1.0. */
+function parseAnalystFinding(value) {
+	const parsed = AnalystFindingSchema.safeParse(value);
+	if (parsed.success) return {
+		succeeded: true,
+		value: parsed.data
+	};
+	const issue = parsed.error.issues[0];
+	return {
+		succeeded: false,
+		error: {
+			path: (issue?.path ?? []).map(String).join("."),
+			message: issue?.message ?? "finding does not match the schema"
+		}
+	};
+}
+function readFindingScope(finding) {
+	if (finding.schema_version === "1.0.0" || !finding.scope || !finding.layer) return {
+		layer: "unknown",
+		n: "unknown",
+		independent_n: "unknown",
+		domain_path: null,
+		labels: ["unscoped"]
+	};
+	const labels = [];
+	if (finding.scope.n < 2) labels.push("anecdote");
+	if (finding.method?.kind === "judged" && finding.method.calibration === void 0) labels.push("uncalibrated");
+	const units = finding.evidence_units;
+	if (units?.some((unit) => unit.derived_from === void 0)) labels.push("lineage-unknown");
+	return {
+		layer: finding.layer,
+		n: finding.scope.n,
+		independent_n: units ? independentUnitCount(units) : "unknown",
+		domain_path: finding.scope.domain_path ?? null,
+		labels
+	};
+}
+/** Root token shared by every unit whose lineage was not recorded. */
+const UNKNOWN_LINEAGE = "?unknown-lineage";
+/**
+* Lineage root of each unit, keyed by unit id. A unit derived from another
+* unit in the list shares that unit's root; a unit derived from an id outside
+* the list takes that id as its root; unknown lineage maps to one shared root.
+*/
+function lineageRoots(units) {
+	const byId = new Map(units.map((unit) => [unit.id, unit]));
+	const roots = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		let current = unit;
+		let root = unit.id;
+		const seen = /* @__PURE__ */ new Set();
+		while (current && !seen.has(current.id)) {
+			seen.add(current.id);
+			if (current.derived_from === void 0) {
+				root = UNKNOWN_LINEAGE;
+				break;
+			}
+			if (current.derived_from === null) {
+				root = current.id;
+				break;
+			}
+			root = current.derived_from;
+			current = byId.get(current.derived_from);
+		}
+		roots.set(unit.id, root);
+	}
+	return roots;
+}
+/** Units with distinct lineage roots. */
+function independentUnitCount(units) {
+	return new Set(lineageRoots(units).values()).size;
+}
+/** One entry per unit id, sorted; a later copy that records lineage fills an earlier unknown. */
+function mergeEvidenceUnits(units) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		const existing = byId.get(unit.id);
+		if (!existing || existing.derived_from === void 0 && unit.derived_from !== void 0) byId.set(unit.id, { ...unit });
+	}
+	return [...byId.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+/** The window spanning every finding's scope window. */
+function spanningWindow(findings) {
+	const windows = findings.map((finding) => finding.scope.window);
+	return {
+		from: windows.map((w) => w.from).reduce((a, b) => Date.parse(b) < Date.parse(a) ? b : a),
+		to: windows.map((w) => w.to).reduce((a, b) => Date.parse(b) > Date.parse(a) ? b : a)
+	};
+}
+function mostSevere(findings) {
+	return ANALYST_SEVERITIES[Math.min(...findings.map((finding) => ANALYST_SEVERITIES.indexOf(finding.severity)))];
+}
+//#endregion
 //#region src/campaign/external-optimizer-contracts.ts
 const MAX_TIMER_DELAY_MS$1 = 2147483647;
 const MAXIMUM_JSON_BYTES = Math.min(constants$1.MAX_LENGTH - 1, constants$1.MAX_STRING_LENGTH);
@@ -1901,6 +2160,6 @@ function summarizeProcessOutput(capture, max = 4e3) {
 	return `${compact.slice(0, headChars)}...[${compact.length - max} chars omitted]...${compact.slice(-tailChars)}`;
 }
 //#endregion
-export { inMemoryCampaignStorage as C, fsCampaignStorage as S, removeCredentialEnvironment as _, closeServer as a, safePathComponent as b, waitForActiveHandlers as c, assertExternalOptimizerModelBudget as d, assertJsonValue as f, isRecord as g, isExternalTextCandidate as h, startExternalOptimizerModelProxy as i, DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS as l, isCandidateText as m, closeExternalOptimizerResources as n, listenLocal as o, assertNoCredentialValues as p, runWithCleanup as r, sendJsonIfOpen as s, runExternalOptimizerProcess as t, DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS as u, resolveExternalOptimizerCallbackLimits as v, createRunCostLedger as x, resolveExternalOptimizerProcessLimits as y };
+export { parseAnalystFinding as A, ProposalFindingSchema as C, lineageRoots as D, independentUnitCount as E, inMemoryCampaignStorage as F, spanningWindow as M, createRunCostLedger as N, mergeEvidenceUnits as O, fsCampaignStorage as P, FINDING_LAYERS as S, findingLayerRank as T, removeCredentialEnvironment as _, closeServer as a, safePathComponent as b, waitForActiveHandlers as c, assertExternalOptimizerModelBudget as d, assertJsonValue as f, isRecord as g, isExternalTextCandidate as h, startExternalOptimizerModelProxy as i, readFindingScope as j, mostSevere as k, DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS as l, isCandidateText as m, closeExternalOptimizerResources as n, listenLocal as o, assertNoCredentialValues as p, runWithCleanup as r, sendJsonIfOpen as s, runExternalOptimizerProcess as t, DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS as u, resolveExternalOptimizerCallbackLimits as v, UNKNOWN_LINEAGE as w, AnalystFindingSchema as x, resolveExternalOptimizerProcessLimits as y };
 
-//# sourceMappingURL=external-optimizer-subprocess-CA3aXT8I.js.map
+//# sourceMappingURL=external-optimizer-subprocess-DcerlZSG.js.map