@tangle-network/agent-eval 0.138.0 → 0.139.0

package/dist/{default-registry-lp5R0lve.js → default-registry-BgJJItGr.js}

@@ -1,58 +1,13 @@
-import { i as CostLedger } from "./cost-ledger-CHDLA0Ss.js";
-import { f as maximumChargeForLlmRequest, l as costReceiptFromLlm, n as LlmClient, s as callLlm, u as costReceiptFromLlmError } from "./llm-client-Cj3c7PEm.js";
+import { n as LlmClient } from "./llm-client-bkztEfIx.js";
 import { LLM_CONTEXT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_OUTPUT_TOKEN_ATTR_KEYS, TOOL_NAME_ATTR_KEYS } from "./trace-attributes.js";
 import { t as executionTrackByLane } from "./execution-tracks-CpgFPpS5.js";
-import { D as spanEpochMillis } from "./store-otlp-BenKynPE.js";
-import { f as validateUsageSettlementTimeout, l as assertValidAnalystUsageReceipt, m as makeFinding, u as settleUsageReceiptFromCostLedger } from "./single-run-lock-D_bS5xhj.js";
-import { _ as canonicalString, v as hashCanonical } from "./ledger-core-C0Yx1I14.js";
-import { a as runTraceAnalysisLoop, r as buildTraceAnalystTools } from "./tools-DZGdROtG.js";
+import { $ as spanEpochMillis, H as snapshotExactExecutionPlan, R as findingSubjectGrammarPromptFor, U as deepFreezeCanonicalJson, V as snapshotExactExecutionComponentIdentity, t as createTraceAnalyst } from "./kind-factory-CFxA0JQX.js";
+import { i as validateUsageSettlementTimeout, o as makeFinding, t as assertValidAnalystUsageReceipt } from "./usage-receipt-CgxMEBZq.js";
+import { i as hashCanonical, r as canonicalString } from "./canonical-D011XM8r.js";
 import { t as analyzeSupervisorRunIntegrity } from "./integrity-CCXTftiL.js";
 import { o as combineAbortSignals } from "./proposal-findings-2GIUo1et.js";
-import { ai } from "@ax-llm/ax";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
-//#region src/analyst/ax-service.ts
-const configuredModels = /* @__PURE__ */ new WeakMap();
-/**
-* Construct the `AxAIService` an analyst kind calls through
-* (`createTraceAnalystKind({ ai })`).
-*
-* Ax's `ai()` pins `config.model` to the OpenAI catalog enum, but every
-* OpenAI-compatible router an analyst points at (router.tangle.tools,
-* cli-bridge) accepts arbitrary model ids (claude-code/sonnet, openai/gpt-5.4,
-* …). Consumers were each re-rolling `ai({ name, apiKey, apiURL, config })`
-* behind an `as (a: any) => any` cast to dodge the enum; this is the one
-* canonical constructor so they don't have to — and don't take a direct
-* `@ax-llm/ax` dependency for it.
-*/
-function createAnalystAi(config) {
-	const model = config.model.trim();
-	if (!model) throw new TypeError("createAnalystAi: model must be a non-empty string");
-	const service = ai({
-		name: config.provider ?? "openai",
-		apiKey: config.apiKey,
-		...config.baseUrl ? { apiURL: config.baseUrl } : {},
-		...config.headers ? { headers: config.headers } : {},
-		config: { model }
-	});
-	configuredModels.set(service, model);
-	return service;
-}
-function getConfiguredAnalystModel(service) {
-	return configuredModels.get(service);
-}
-/** Resolve the model before paid work so every request can be bounded and attributed. */
-function resolveAnalystModel(service, override) {
-	if (override !== void 0) {
-		const model = override.trim();
-		if (!model) throw new TypeError("createTraceAnalystKind: model must be a non-empty string");
-		return model;
-	}
-	const model = getConfiguredAnalystModel(service)?.trim();
-	if (!model) throw new TypeError("createTraceAnalystKind: model is required for Ax services not created by createAnalystAi()");
-	return model;
-}
-//#endregion
 //#region src/analyst/chat-client.ts
 /**
 * Provider-neutral chat contract for every model call made by agent-eval.
@@ -608,1362 +563,6 @@ function positiveInteger(value, name) {
 	return value;
 }
 //#endregion
-//#region src/analyst/ax-cost-service.ts
-/**
-* Meter every chat call an Ax program makes through the shared paid-call ledger.
-* The wrapper disables provider streaming because a stream has no complete usage
-* receipt until it is consumed, while Ax's analyst output is not streamed to users.
-*/
-function meterAxChatService(ai, options) {
-	assertPositiveInteger(options.maxOutputTokens, "maxOutputTokens");
-	const source = ai;
-	if (typeof source.chat !== "function") throw new TypeError("meterAxChatService: Ax service must implement chat()");
-	const providerChat = source.chat.bind(ai);
-	const chat = async (request, callOptions = {}) => {
-		const boundedRequest = boundOutputTokens(request, options.maxOutputTokens);
-		const model = modelName(boundedRequest.model) || options.defaultModel || "";
-		const canTurnOffThinking = canDisableThinking(ai, model);
-		const combined = combineSignals(options.signal, callOptions.abortSignal);
-		try {
-			const paid = await options.ledger.runPaidCall({
-				channel: "analyst",
-				phase: options.phase ?? "analyst.ax.chat",
-				actor: options.actor,
-				model,
-				tags: options.tags,
-				signal: combined.signal,
-				maximumCharge: maximumChargeForAxChatRequest(boundedRequest, model),
-				execute: async (executionSignal) => {
-					const providerOptions = {
-						...callOptions,
-						abortSignal: executionSignal,
-						retry: {
-							...callOptions.retry,
-							maxRetries: 0
-						},
-						stream: false,
-						showThoughts: false
-					};
-					if (canTurnOffThinking) providerOptions.thinkingTokenBudget = "none";
-					else Reflect.deleteProperty(providerOptions, "thinkingTokenBudget");
-					const response = await providerChat(boundedRequest, providerOptions);
-					if (response instanceof ReadableStream) throw new Error("meterAxChatService: provider returned a stream after stream:false");
-					return response;
-				},
-				receipt: (response) => costReceiptFromAxResponse(response, model)
-			});
-			if (!paid.succeeded) throw paid.error;
-			return paid.value;
-		} finally {
-			combined.dispose();
-		}
-	};
-	return new Proxy(ai, { get(target, property) {
-		if (property === "chat") return chat;
-		const value = Reflect.get(target, property, target);
-		return typeof value === "function" ? value.bind(target) : value;
-	} });
-}
-/** Conservative priced bound for one Ax text chat request. */
-function maximumChargeForAxChatRequest(request, defaultModel) {
-	const model = modelName(request.model) || defaultModel || "";
-	const maxTokens = request.modelConfig?.maxTokens;
-	const completions = request.modelConfig?.n;
-	if (!model || maxTokens === void 0 || completions === void 0) return void 0;
-	assertPositiveInteger(maxTokens, "request.modelConfig.maxTokens");
-	assertPositiveInteger(completions, "request.modelConfig.n");
-	const maximumOutputTokens = maxTokens * completions;
-	assertPositiveInteger(maximumOutputTokens, "maximum output tokens");
-	if (containsUnboundedOrCacheableContent(request)) return void 0;
-	let inputTokens;
-	try {
-		const pricedRequest = request.model === void 0 ? {
-			...request,
-			model
-		} : request;
-		inputTokens = new TextEncoder().encode(JSON.stringify(pricedRequest)).byteLength * completions;
-	} catch {
-		return;
-	}
-	assertPositiveInteger(inputTokens, "maximum input tokens");
-	return {
-		model,
-		inputTokens,
-		outputTokens: maximumOutputTokens
-	};
-}
-function boundOutputTokens(request, limit) {
-	const requested = request.modelConfig?.maxTokens;
-	if (requested !== void 0) assertPositiveInteger(requested, "request.modelConfig.maxTokens");
-	const completions = request.modelConfig?.n ?? 1;
-	assertPositiveInteger(completions, "request.modelConfig.n");
-	const maxTokens = requested === void 0 ? limit : Math.min(requested, limit);
-	return {
-		...request,
-		...request.functionCall === void 0 && !request.functions?.length ? { functionCall: "none" } : {},
-		modelConfig: {
-			...request.modelConfig,
-			maxTokens,
-			n: completions
-		}
-	};
-}
-function costReceiptFromAxResponse(response, fallbackModel) {
-	const usage = response.modelUsage;
-	const tokens = usage?.tokens;
-	const model = usage?.model || fallbackModel;
-	if (!tokens || !validUsage(tokens.promptTokens) || !validUsage(tokens.completionTokens) || !validUsage(tokens.totalTokens) || tokens.totalTokens < tokens.promptTokens + tokens.completionTokens || !validOptionalUsage(tokens.cacheReadTokens) || !validOptionalUsage(tokens.cacheCreationTokens) || !validOptionalUsage(tokens.reasoningTokens) || !validOptionalUsage(tokens.thoughtsTokens)) return {
-		model,
-		inputTokens: 0,
-		outputTokens: 0,
-		usageUnknown: true
-	};
-	const cacheReadTokens = validUsage(tokens.cacheReadTokens) ? tokens.cacheReadTokens : 0;
-	const cacheCreationTokens = validUsage(tokens.cacheCreationTokens) ? tokens.cacheCreationTokens : 0;
-	const totalCacheTokens = cacheReadTokens + cacheCreationTokens;
-	const thoughtsTokens = validUsage(tokens.thoughtsTokens) ? tokens.thoughtsTokens : 0;
-	const reasoningTokens = Math.max(validUsage(tokens.reasoningTokens) ? tokens.reasoningTokens : 0, thoughtsTokens);
-	const separateReasoningTokens = reasoningTokens > tokens.completionTokens ? reasoningTokens : 0;
-	const additionalOutputTokens = Math.max(thoughtsTokens, separateReasoningTokens);
-	const outputTokens = tokens.completionTokens + additionalOutputTokens;
-	const directTotal = tokens.promptTokens + tokens.completionTokens;
-	if (!(/* @__PURE__ */ new Set([
-		directTotal,
-		directTotal + totalCacheTokens,
-		directTotal + additionalOutputTokens,
-		directTotal + totalCacheTokens + additionalOutputTokens
-	])).has(tokens.totalTokens)) return {
-		model,
-		inputTokens: 0,
-		outputTokens: 0,
-		usageUnknown: true
-	};
-	return {
-		model,
-		inputTokens: tokens.promptTokens,
-		outputTokens,
-		...reasoningTokens > 0 ? { reasoningTokens } : {},
-		...cacheReadTokens > 0 ? { cachedTokens: cacheReadTokens } : {},
-		...cacheCreationTokens > 0 ? { cacheWriteTokens: cacheCreationTokens } : {}
-	};
-}
-function combineSignals(first, second) {
-	if (!first) return {
-		signal: second,
-		dispose: () => {}
-	};
-	if (!second || first === second) return {
-		signal: first,
-		dispose: () => {}
-	};
-	if (typeof AbortSignal.any === "function") return {
-		signal: AbortSignal.any([first, second]),
-		dispose: () => {}
-	};
-	const controller = new AbortController();
-	const dispose = () => {
-		first.removeEventListener("abort", abortFromFirst);
-		second.removeEventListener("abort", abortFromSecond);
-	};
-	const abortFrom = (source) => {
-		if (!controller.signal.aborted) controller.abort(source.reason);
-		dispose();
-	};
-	const abortFromFirst = () => abortFrom(first);
-	const abortFromSecond = () => abortFrom(second);
-	if (first.aborted) abortFrom(first);
-	else if (second.aborted) abortFrom(second);
-	else {
-		first.addEventListener("abort", abortFromFirst, { once: true });
-		second.addEventListener("abort", abortFromSecond, { once: true });
-	}
-	return {
-		signal: controller.signal,
-		dispose
-	};
-}
-function containsUnboundedOrCacheableContent(request) {
-	if (request.functions?.some((fn) => fn.cache === true)) return true;
-	return request.chatPrompt.some((message) => {
-		if (message.cache === true) return true;
-		if (!("content" in message) || !Array.isArray(message.content)) return false;
-		return message.content.some((part) => part.cache === true || part.type !== "text");
-	});
-}
-function modelName(value) {
-	return typeof value === "string" ? value : "";
-}
-function canDisableThinking(ai, model) {
-	const namedAi = ai;
-	const serviceName = typeof namedAi.getName === "function" ? namedAi.getName() : "";
-	const modelId = model.slice(model.lastIndexOf("/") + 1);
-	return serviceName !== "GoogleGeminiAI" || !/^gemini-3(?:[.-]|$)/i.test(modelId);
-}
-function validUsage(value) {
-	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function validOptionalUsage(value) {
-	return value === void 0 || validUsage(value);
-}
-function assertPositiveInteger(value, field) {
-	if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`meterAxChatService: ${field} must be a positive integer`);
-}
-//#endregion
-//#region src/ledger-core/deep-freeze.ts
-/** Freeze a detached canonical-JSON graph. Canonicalization has already ruled out cycles.
-*
-* Lives outside canonical.ts so the analyst-benchmark implementation digest,
-* which covers canonical.ts, stays bound to the published benchmark evidence. */
-function deepFreezeCanonicalJson(value) {
-	if (value && typeof value === "object" && !Object.isFrozen(value)) {
-		Object.freeze(value);
-		for (const nested of Object.values(value)) deepFreezeCanonicalJson(nested);
-	}
-	return value;
-}
-//#endregion
-//#region src/analyst/exact-types.ts
-/** Canonical identity for any live component admitted to an exact run. */
-function snapshotExactExecutionComponentIdentity(value, context) {
-	let detached;
-	try {
-		detached = JSON.parse(canonicalString(value));
-	} catch (cause) {
-		throw new TypeError(`${context} must have a canonical JSON representation`, { cause });
-	}
-	const parsed = componentIdentitySchema.safeParse(detached);
-	if (!parsed.success) throw new TypeError(`${context} requires non-empty id/version and object config`);
-	return deepFreezeCanonicalJson({
-		id: parsed.data.id,
-		version: parsed.data.version,
-		config_digest: hashCanonical(parsed.data.config)
-	});
-}
-const nonEmptyString = z.string().min(1);
-const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-const finiteNonnegative$1 = z.number().finite().nonnegative();
-const nonnegativeSafeInteger$1 = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
-const positiveTimeout = z.number().int().positive().max(2147483647);
-const componentSnapshotSchema = z.strictObject({
-	id: nonEmptyString,
-	version: nonEmptyString,
-	config_digest: digest
-});
-const componentIdentitySchema = z.strictObject({
-	id: nonEmptyString,
-	version: nonEmptyString,
-	config: z.record(z.string(), z.unknown())
-});
-const deterministicCostSchema = z.strictObject({
-	kind: z.literal("deterministic"),
-	est_usd_per_run: finiteNonnegative$1.optional(),
-	models: z.array(nonEmptyString).optional()
-});
-const llmCostSchema = z.strictObject({
-	kind: z.literal("llm"),
-	est_usd_per_run: finiteNonnegative$1.optional(),
-	models: z.array(nonEmptyString).optional(),
-	settlement_timeout_ms: nonnegativeSafeInteger$1.optional()
-});
-const requirementsSchema = z.strictObject({
-	min_shots: nonnegativeSafeInteger$1.optional(),
-	capabilities: z.array(nonEmptyString).optional()
-}).nullable();
-const analystSnapshotSchema = z.strictObject({
-	id: nonEmptyString,
-	version: nonEmptyString,
-	input_kind: z.enum([
-		"trace-store",
-		"artifact-dir",
-		"run-record",
-		"judge-input",
-		"custom"
-	]),
-	cost: z.discriminatedUnion("kind", [deterministicCostSchema, llmCostSchema]),
-	requirements: requirementsSchema,
-	execution_config_digest: digest
-});
-const allocationsSchema = z.record(nonEmptyString, z.union([finiteNonnegative$1, z.null()]));
-const weightsSchema = z.record(nonEmptyString, finiteNonnegative$1);
-const budgetSnapshotSchema = z.discriminatedUnion("kind", [
-	z.strictObject({ kind: z.literal("none") }),
-	z.strictObject({
-		kind: z.literal("equal"),
-		total_usd: finiteNonnegative$1,
-		allocations_usd: allocationsSchema
-	}),
-	z.strictObject({
-		kind: z.literal("weighted"),
-		total_usd: finiteNonnegative$1,
-		weights: weightsSchema,
-		allocations_usd: allocationsSchema
-	})
-]);
-const priorFindingsSchema = z.discriminatedUnion("kind", [
-	z.strictObject({ kind: z.literal("none") }),
-	z.strictObject({
-		kind: z.literal("ordered"),
-		count: nonnegativeSafeInteger$1,
-		digest
-	}),
-	z.strictObject({
-		kind: z.literal("by_analyst"),
-		keys: z.array(nonEmptyString),
-		count: nonnegativeSafeInteger$1,
-		digest
-	})
-]);
-const exactRunPolicySchema = z.strictObject({
-	budget: budgetSnapshotSchema,
-	total_timeout_ms: positiveTimeout.nullable(),
-	signal_provided: z.boolean(),
-	cost_ledger: componentSnapshotSchema.nullable(),
-	cost_phase: nonEmptyString.nullable(),
-	tags: z.record(z.string(), z.string()).nullable(),
-	prior_findings: priorFindingsSchema,
-	chain_findings: z.boolean(),
-	missing_input_mode: z.enum(["skip", "abort"]),
-	registry_hooks: componentSnapshotSchema.nullable(),
-	registry_chat: componentSnapshotSchema.nullable()
-});
-const exactExecutionPlanSchema = z.strictObject({
-	schema_version: z.literal("1.0.0"),
-	analysts: z.array(analystSnapshotSchema).min(1),
-	policy: exactRunPolicySchema,
-	digest
-}).superRefine((plan, context) => {
-	const issue = (path, message) => context.addIssue({
-		code: "custom",
-		path,
-		message
-	});
-	const analystIds = plan.analysts.map((analyst) => analyst.id);
-	if (new Set(analystIds).size !== analystIds.length) issue(["analysts"], "analyst ids must be unique");
-	if (plan.policy.cost_ledger === null && plan.policy.cost_phase !== null) issue(["policy", "cost_phase"], "cost phase requires a cost ledger");
-	if (plan.policy.prior_findings.kind === "by_analyst" && plan.policy.prior_findings.keys.some((key, index, keys) => index > 0 && key <= keys[index - 1])) issue([
-		"policy",
-		"prior_findings",
-		"keys"
-	], "keys must be sorted and unique");
-	const budget = plan.policy.budget;
-	if (budget.kind === "none") return;
-	const allocationIds = Object.keys(budget.allocations_usd).sort();
-	const selectedIds = [...analystIds].sort();
-	if (allocationIds.length !== selectedIds.length || allocationIds.some((id, index) => id !== selectedIds[index])) {
-		issue([
-			"policy",
-			"budget",
-			"allocations_usd"
-		], "allocations must name every analyst and no others");
-		return;
-	}
-	const runnableIds = analystIds.filter((id) => budget.allocations_usd[id] !== null);
-	const epsilon = Math.max(1, budget.total_usd) * Number.EPSILON * 8;
-	if (runnableIds.length === 0) return;
-	if (budget.kind === "weighted") {
-		const weightIds = Object.keys(budget.weights).sort();
-		if (weightIds.length !== selectedIds.length || weightIds.some((id, index) => id !== selectedIds[index])) {
-			issue([
-				"policy",
-				"budget",
-				"weights"
-			], "weights must name every analyst and no others");
-			return;
-		}
-		const totalWeight = runnableIds.reduce((sum, id) => sum + (budget.weights[id] ?? 0), 0);
-		if (totalWeight === 0) {
-			issue([
-				"policy",
-				"budget",
-				"weights"
-			], "runnable analysts must have positive total weight");
-			return;
-		}
-		for (const id of runnableIds) {
-			const expected = budget.total_usd * (budget.weights[id] ?? 0) / totalWeight;
-			if (Math.abs((budget.allocations_usd[id] ?? 0) - expected) > epsilon) issue([
-				"policy",
-				"budget",
-				"allocations_usd",
-				id
-			], "allocation does not match the weighted policy");
-		}
-		return;
-	}
-	const expected = budget.total_usd / runnableIds.length;
-	for (const id of runnableIds) if (Math.abs((budget.allocations_usd[id] ?? 0) - expected) > epsilon) issue([
-		"policy",
-		"budget",
-		"allocations_usd",
-		id
-	], "allocation does not match the equal policy");
-});
-/**
-* Canonicalize and validate the one exact-plan representation shared by execution and archival.
-* Unknown fields fail at every level; the returned graph is detached and deeply frozen.
-*/
-function snapshotExactExecutionPlan(value, context = "exact analyst execution plan") {
-	let detached;
-	try {
-		detached = JSON.parse(canonicalString(value));
-	} catch (cause) {
-		throw new TypeError(`${context} must have a canonical JSON representation`, { cause });
-	}
-	const parsed = exactExecutionPlanSchema.safeParse(detached);
-	if (!parsed.success) {
-		const issue = parsed.error.issues[0];
-		const path = issue?.path.length ? ` ${issue.path.join(".")}` : "";
-		throw new TypeError(`${context}${path}: ${issue?.message ?? "is invalid"}`);
-	}
-	const expectedDigest = hashCanonical({
-		schema_version: parsed.data.schema_version,
-		analysts: parsed.data.analysts,
-		policy: parsed.data.policy
-	});
-	if (parsed.data.digest !== expectedDigest) throw new TypeError(`${context} digest does not match its content`);
-	return deepFreezeCanonicalJson(parsed.data);
-}
-//#endregion
-//#region src/analyst/finding-subject.ts
-/**
-* Typed `FindingSubject` — the canonical grammar every analyst kind emits.
-*
-* Background: kind actor prompts have always documented a subject grammar
-* (e.g. `system-prompt:<section>`, `agent-knowledge:wiki:<slug>`) but the
-* LLM was unconstrained — it could emit `subject: "fix the prompt"`
-* (prose) and downstream adapters routed on `startsWith(...)` would
-* silently skip it. Every per-vertical `ImprovementAdapter` had a
-* routing table that mostly caught nothing.
-*
-* This module fixes that:
-*   - `parseFindingSubject(raw)` — returns the typed `FindingSubject`
-*     when `raw` matches the grammar, else `null`. Used at the
-*     `RawAnalystFindingSchema` boundary so malformed subjects are
-*     rejected loudly instead of silently lifted into the registry.
-*   - `FindingSubjectKind` — the union of valid locus categories. Each
-*     variant carries the typed components downstream adapters resolve
-*     against the agent's surface manifest (no string parsing in the
-*     adapter).
-*   - `FINDING_SUBJECT_GRAMMAR_PROMPT` — single source of truth for the
-*     grammar string embedded in kind actor prompts. Drift between
-*     prompt and parser is impossible if every kind imports this.
-*
-* The grammar is intentionally NARROW — only loci the substrate's
-* default `ImprovementAdapter` / `KnowledgeAdapter` can act on. A
-* finding with a subject outside this set fails the parser; the kind
-* author either extends the grammar here (and adds adapter routing)
-* or rephrases the prompt to map onto an existing variant.
-*
-* `failure-mode` is the one exception — its subjects are free-form
-* cluster labels, not loci. The schema preserves them as
-* `{ kind: 'cluster', label }` and the adapters skip them (cluster
-* findings are evidence, not actionable mutations).
-*/
-const FINDING_SUBJECT_KINDS = [
-	"knowledge.wiki",
-	"knowledge.claim",
-	"knowledge.raw",
-	"knowledge.stale",
-	"system-prompt",
-	"skill",
-	"tool-doc",
-	"new-tool",
-	"mcp",
-	"hook",
-	"subagent",
-	"workflow",
-	"rollout-policy",
-	"agent-profile",
-	"code",
-	"rag",
-	"memory",
-	"scaffolding",
-	"output-schema",
-	"websearch.outdated",
-	"prior-run-summary",
-	"cluster"
-];
-/**
-* Parse a raw subject string emitted by an analyst kind's actor.
-*
-* Returns the typed `FindingSubject` when `raw` matches the grammar,
-* else `null`. Callers use the `null` return as a signal to either
-* (a) reject the finding at parse time (kinds that emit typed loci —
-* knowledge-gap, improvement, knowledge-poisoning) or (b) lift it as
-* a cluster label (failure-mode).
-*
-* Slugs are constrained to `[a-z0-9-]+` (lowercase kebab) to keep file
-* paths sane downstream. Topics / keys / sections allow any non-empty
-* string (free-form for the LLM's voice) but get trimmed.
-*
-* Empty / whitespace-only inputs return `null`. `undefined` returns
-* `null`. Both are surfaced by the caller as a rejected subject.
-*/
-function parseFindingSubject(raw) {
-	if (raw === null || raw === void 0) return null;
-	const trimmed = raw.trim();
-	if (trimmed.length === 0) return null;
-	const wiki = trimmed.match(/^agent-knowledge:wiki:([a-z0-9][a-z0-9-]*)(?:#([a-z0-9][a-z0-9-]*))?$/);
-	if (wiki) return {
-		kind: "knowledge.wiki",
-		slug: wiki[1],
-		...wiki[2] ? { heading: wiki[2] } : {}
-	};
-	const claim = trimmed.match(/^agent-knowledge:claim:(.+)$/);
-	if (claim && claim[1].trim().length > 0) return {
-		kind: "knowledge.claim",
-		topic: claim[1].trim()
-	};
-	const raw_ = trimmed.match(/^agent-knowledge:raw:(.+)$/);
-	if (raw_ && raw_[1].trim().length > 0) return {
-		kind: "knowledge.raw",
-		sourceId: raw_[1].trim()
-	};
-	const stale = trimmed.match(/^agent-knowledge:stale:([a-z0-9][a-z0-9-]*)$/);
-	if (stale) return {
-		kind: "knowledge.stale",
-		slug: stale[1]
-	};
-	const sp = trimmed.match(/^system-prompt:(.+)$/);
-	if (sp && sp[1].trim().length > 0) return {
-		kind: "system-prompt",
-		section: sp[1].trim()
-	};
-	const skill = trimmed.match(/^skill:([a-z0-9][a-z0-9_.-]*)$/);
-	if (skill) return {
-		kind: "skill",
-		name: skill[1]
-	};
-	const tdAspect = trimmed.match(/^tool-doc:([a-z0-9][a-z0-9_-]*):(.+)$/);
-	if (tdAspect && tdAspect[2].trim().length > 0) return {
-		kind: "tool-doc",
-		tool: tdAspect[1],
-		aspect: tdAspect[2].trim()
-	};
-	const td = trimmed.match(/^tool-doc:([a-z0-9][a-z0-9_-]*)$/);
-	if (td) return {
-		kind: "tool-doc",
-		tool: td[1]
-	};
-	const nt = trimmed.match(/^new-tool:([a-z0-9][a-z0-9_-]*)$/);
-	if (nt) return {
-		kind: "new-tool",
-		name: nt[1]
-	};
-	const mcp = trimmed.match(/^mcp:([a-z0-9][a-z0-9_.-]*)(?::([a-z0-9][a-z0-9_.-]*))?$/);
-	if (mcp) return {
-		kind: "mcp",
-		server: mcp[1],
-		...mcp[2] ? { tool: mcp[2] } : {}
-	};
-	const hook = trimmed.match(/^hook:([a-z0-9][a-z0-9_.-]*)$/);
-	if (hook) return {
-		kind: "hook",
-		name: hook[1]
-	};
-	const subagent = trimmed.match(/^subagent:([a-z0-9][a-z0-9_.-]*)$/);
-	if (subagent) return {
-		kind: "subagent",
-		name: subagent[1]
-	};
-	const workflow = trimmed.match(/^workflow:([a-z0-9][a-z0-9_.-]*)$/);
-	if (workflow) return {
-		kind: "workflow",
-		name: workflow[1]
-	};
-	const rolloutPolicy = trimmed.match(/^rollout-policy:(.+)$/);
-	if (rolloutPolicy && rolloutPolicy[1].trim().length > 0) return {
-		kind: "rollout-policy",
-		field: rolloutPolicy[1].trim()
-	};
-	const agentProfile = trimmed.match(/^agent-profile:(.+)$/);
-	if (agentProfile && agentProfile[1].trim().length > 0) return {
-		kind: "agent-profile",
-		field: agentProfile[1].trim()
-	};
-	const code = trimmed.match(/^code:(.+)$/);
-	if (code && code[1].trim().length > 0) return {
-		kind: "code",
-		path: code[1].trim()
-	};
-	const rag = trimmed.match(/^rag:([a-z0-9][a-z0-9_-]*):(.+)$/);
-	if (rag && rag[2].trim().length > 0) return {
-		kind: "rag",
-		corpus: rag[1],
-		docId: rag[2].trim()
-	};
-	const mem = trimmed.match(/^memory:(.+)$/);
-	if (mem && mem[1].trim().length > 0) return {
-		kind: "memory",
-		key: mem[1].trim()
-	};
-	const sc = trimmed.match(/^scaffolding:(.+)$/);
-	if (sc && sc[1].trim().length > 0) return {
-		kind: "scaffolding",
-		concern: sc[1].trim()
-	};
-	const os = trimmed.match(/^output-schema:(.+)$/);
-	if (os && os[1].trim().length > 0) return {
-		kind: "output-schema",
-		field: os[1].trim()
-	};
-	const ws = trimmed.match(/^websearch:outdated:(.+)$/);
-	if (ws && ws[1].trim().length > 0) return {
-		kind: "websearch.outdated",
-		topic: ws[1].trim()
-	};
-	const prs = trimmed.match(/^prior-run-summary:(.+)$/);
-	if (prs && prs[1].trim().length > 0) return {
-		kind: "prior-run-summary",
-		topic: prs[1].trim()
-	};
-	if (/^[a-z0-9][a-z0-9._-]*$/.test(trimmed) && trimmed.length <= 80) return {
-		kind: "cluster",
-		label: trimmed
-	};
-	return null;
-}
-/**
-* Render the parsed subject back to its canonical string form. Inverse
-* of `parseFindingSubject`; useful when the substrate constructs new
-* findings programmatically (e.g. for tests, replays, or
-* `id_basis` carry-forward).
-*/
-function renderFindingSubject(s) {
-	switch (s.kind) {
-		case "knowledge.wiki": return s.heading ? `agent-knowledge:wiki:${s.slug}#${s.heading}` : `agent-knowledge:wiki:${s.slug}`;
-		case "knowledge.claim": return `agent-knowledge:claim:${s.topic}`;
-		case "knowledge.raw": return `agent-knowledge:raw:${s.sourceId}`;
-		case "knowledge.stale": return `agent-knowledge:stale:${s.slug}`;
-		case "system-prompt": return `system-prompt:${s.section}`;
-		case "skill": return `skill:${s.name}`;
-		case "tool-doc": return s.aspect ? `tool-doc:${s.tool}:${s.aspect}` : `tool-doc:${s.tool}`;
-		case "new-tool": return `new-tool:${s.name}`;
-		case "mcp": return s.tool ? `mcp:${s.server}:${s.tool}` : `mcp:${s.server}`;
-		case "hook": return `hook:${s.name}`;
-		case "subagent": return `subagent:${s.name}`;
-		case "workflow": return `workflow:${s.name}`;
-		case "rollout-policy": return `rollout-policy:${s.field}`;
-		case "agent-profile": return `agent-profile:${s.field}`;
-		case "code": return `code:${s.path}`;
-		case "rag": return `rag:${s.corpus}:${s.docId}`;
-		case "memory": return `memory:${s.key}`;
-		case "scaffolding": return `scaffolding:${s.concern}`;
-		case "output-schema": return `output-schema:${s.field}`;
-		case "websearch.outdated": return `websearch:outdated:${s.topic}`;
-		case "prior-run-summary": return `prior-run-summary:${s.topic}`;
-		case "cluster": return s.label;
-	}
-}
-/**
-* The grammar text embedded into kind actor prompts. Kinds opt into
-* the subset of variants they emit (e.g. `improvement` excludes the
-* cluster variant; `failure-mode` includes ONLY the cluster variant).
-*
-* Drift between prompt and parser is impossible: every kind imports
-* this constant + the matching `expects` set, and the unit tests below
-* lock the table to the parser.
-*/
-const FINDING_SUBJECT_SYNTAX = {
-	"knowledge.wiki": "agent-knowledge:wiki:<slug>[#<heading>]",
-	"knowledge.claim": "agent-knowledge:claim:<topic>",
-	"knowledge.raw": "agent-knowledge:raw:<source-id>",
-	"knowledge.stale": "agent-knowledge:stale:<slug>",
-	"system-prompt": "system-prompt:<section>",
-	skill: "skill:<name>",
-	"tool-doc": "tool-doc:<tool>[:<aspect>]",
-	"new-tool": "new-tool:<name>",
-	mcp: "mcp:<server>[:<tool>]",
-	hook: "hook:<name>",
-	subagent: "subagent:<name>",
-	workflow: "workflow:<name>",
-	"rollout-policy": "rollout-policy:<field>",
-	"agent-profile": "agent-profile:<field>",
-	code: "code:<path>",
-	rag: "rag:<corpus>:<doc-id>",
-	memory: "memory:<key>",
-	scaffolding: "scaffolding:<concern>",
-	"output-schema": "output-schema:<field>",
-	"websearch.outdated": "websearch:outdated:<topic>",
-	"prior-run-summary": "prior-run-summary:<topic>",
-	cluster: "<lowercase-cluster-label>"
-};
-const FINDING_SUBJECT_PURPOSE = {
-	"knowledge.wiki": "create or update a wiki page",
-	"knowledge.claim": "draft a claim or relation",
-	"knowledge.raw": "curate a raw source",
-	"knowledge.stale": "mark a stale page",
-	"system-prompt": "revise a system-prompt section",
-	skill: "create or revise a skill",
-	"tool-doc": "revise a tool contract",
-	"new-tool": "propose a new tool",
-	mcp: "revise an MCP server or tool",
-	hook: "revise a lifecycle hook",
-	subagent: "revise a delegated agent",
-	workflow: "revise an orchestration workflow",
-	"rollout-policy": "revise budget, sampling, or stop policy",
-	"agent-profile": "revise another AgentProfile field",
-	code: "revise an implementation path",
-	rag: "ingest or correct a RAG document",
-	memory: "invalidate or set memory",
-	scaffolding: "revise preconditions, retries, or verification",
-	"output-schema": "constrain the output shape",
-	"websearch.outdated": "identify a stale web result",
-	"prior-run-summary": "identify a stale prior-run summary",
-	cluster: "name one failure cluster"
-};
-function renderFindingSubjectGrammar(kinds) {
-	return [
-		"Subjects MUST match one of these forms — anything else is rejected at parse time:",
-		...kinds.map((kind) => `  ${FINDING_SUBJECT_SYNTAX[kind]} — ${FINDING_SUBJECT_PURPOSE[kind]}`),
-		"Runtime ids are lowercase [a-z0-9_.-]+. Topics, keys, paths, and sections are free-form and trimmed."
-	].join("\n");
-}
-const FINDING_SUBJECT_GRAMMAR_PROMPT = renderFindingSubjectGrammar(FINDING_SUBJECT_KINDS);
-/**
-* The variants each kind is allowed to emit. Used at the kind factory
-* boundary so a knowledge-gap finding can't sneak in a `system-prompt:*`
-* subject (the improvement-analyst's job) and vice versa.
-*
-* `failure-mode` is restricted to `cluster` — the only kind that emits
-* a non-locus subject.
-*/
-const KIND_EXPECTED_SUBJECTS = {
-	"failure-mode": ["cluster"],
-	"knowledge-gap": [
-		"knowledge.wiki",
-		"knowledge.claim",
-		"knowledge.raw",
-		"knowledge.stale",
-		"tool-doc",
-		"system-prompt",
-		"skill",
-		"mcp",
-		"subagent",
-		"workflow",
-		"memory",
-		"websearch.outdated",
-		"prior-run-summary"
-	],
-	"knowledge-poisoning": [
-		"knowledge.wiki",
-		"knowledge.claim",
-		"knowledge.raw",
-		"tool-doc",
-		"system-prompt",
-		"skill",
-		"mcp",
-		"hook",
-		"memory",
-		"websearch.outdated",
-		"prior-run-summary"
-	],
-	improvement: [
-		"system-prompt",
-		"skill",
-		"tool-doc",
-		"new-tool",
-		"mcp",
-		"hook",
-		"subagent",
-		"workflow",
-		"rollout-policy",
-		"agent-profile",
-		"code",
-		"rag",
-		"memory",
-		"scaffolding",
-		"output-schema",
-		"knowledge.wiki",
-		"knowledge.claim"
-	]
-};
-/** Render only the subject forms one analyst kind is permitted to emit. */
-function findingSubjectGrammarPromptFor(kindId) {
-	const kinds = KIND_EXPECTED_SUBJECTS[kindId];
-	if (!kinds) throw new Error(`unknown analyst kind: ${kindId}`);
-	return renderFindingSubjectGrammar(kinds);
-}
-/**
-* Zod schema that validates a raw subject string and returns the parsed
-* `FindingSubject`. Embedded in `RawAnalystFindingSchema` via
-* `transform`, so `subject` arrives at the kind factory either as a
-* typed locus or as a parse error attached to a single Zod issue.
-*
-* Optionality is preserved: subjects ARE optional on the wire (some
-* findings are descriptive, not actionable). When present, they MUST
-* parse — emitting a malformed subject is a contract violation, not a
-* soft signal.
-*/
-const FindingSubjectStringSchema = z.string().refine((s) => parseFindingSubject(s) !== null, { message: "subject does not match the finding-subject grammar" });
-//#endregion
-//#region src/analyst/parse-tolerant.ts
-/**
-* Forgiving pre-parse for analyst findings. Weak models routinely emit
-* schema-correct content in an unusable wrapper — fenced ```json blocks, a
-* single object where an array is expected, trailing commas. Measured: GPT-4o
-* drops to 0% usable output purely from markdown-fence wrapping
-* (arXiv:2605.02363). A five-line de-fence recovers most of it. This module is
-* the de-fence/coerce step that runs BEFORE Zod, so a recoverable finding is
-* repaired, not dropped.
-*
-* Pure + deterministic. No model, no network.
-*/
-/** Strip a ```lang ... ``` (or bare ``` ... ```) code fence, if the string is one. */
-function stripCodeFences(text) {
-	const t = text.trim();
-	const m = t.match(/^```[a-zA-Z0-9]*\s*\n?([\s\S]*?)\n?```$/);
-	return m ? m[1].trim() : t;
-}
-/** Remove trailing commas before } or ] — the most common near-JSON defect. */
-function dropTrailingCommas(s) {
-	return s.replace(/,(\s*[}\]])/g, "$1");
-}
-/**
-* Best-effort parse of a string into JSON. De-fences, drops trailing commas,
-* then `JSON.parse`. Returns `undefined` (never throws) when unrecoverable.
-*/
-function coerceJson(text) {
-	const candidate = dropTrailingCommas(stripCodeFences(text));
-	try {
-		return JSON.parse(candidate);
-	} catch {
-		return;
-	}
-}
-/**
-* Coerce arbitrary actor/structurer output into an array of candidate finding
-* rows: a JSON string → parse; a single object → 1-element array; an array →
-* as-is; anything else → []. Callers still run each row through Zod
-* (`parseRawFinding`) — this only fixes the shape and never invents fields.
-*/
-function coerceToFindingRows(raw) {
-	let value = raw;
-	if (typeof value === "string") {
-		const parsed = coerceJson(value);
-		if (parsed === void 0) return [];
-		value = parsed;
-	}
-	if (Array.isArray(value)) return value;
-	if (value && typeof value === "object") {
-		const inner = value.findings;
-		if (Array.isArray(inner)) return inner;
-		return [value];
-	}
-	return [];
-}
-//#endregion
-//#region src/analyst/finding-signature.ts
-/**
-* Typed Ax output for analyst findings.
-*
-* Ax binds the field as `findings:json[]` so the provider emits native
-* structured output. At the kind-factory boundary every row is validated
-* before it becomes an `AnalystFinding`.
-*
-* Why not `f.object().array()` directly in the signature? The Ax
-* signature string `question:string -> findings:json[]` already lets
-* the provider emit JSON arrays. A Zod boundary is required either
-* way (the provider can return any JSON), and Zod gives us a single
-* validation surface independent of which Ax version is installed.
-*/
-const ANALYST_SEVERITIES = [
-	"critical",
-	"high",
-	"medium",
-	"low",
-	"info"
-];
-const RawAnalystEvidenceSchema = z.object({
-	uri: z.string().trim().min(1).max(2e3),
-	excerpt: z.string().max(2e3).optional()
-}).strict();
-const RawAnalystFindingBaseShape = {
-	severity: z.enum(ANALYST_SEVERITIES),
-	claim: z.string().min(1).max(2e3),
-	subject: z.string().max(400).refine((subject) => parseFindingSubject(subject) !== null, { message: "subject does not match the finding-subject grammar" }).optional(),
-	confidence: z.number().min(0).max(1),
-	rationale: z.string().max(4e3).optional(),
-	recommended_action: z.string().max(2e3).optional()
-};
-const RawAnalystFindingSchema = z.object({
-	...RawAnalystFindingBaseShape,
-	evidence: z.array(RawAnalystEvidenceSchema).min(1)
-}).strict();
-/**
-* Description embedded into the actor prompt so the LLM knows what
-* shape to emit. Kept here so kinds share one source of truth rather
-* than restating the schema in every prompt.
-*/
-const RAW_FINDING_SCHEMA_PROMPT = `Each finding MUST be a strict JSON object with:
-  - severity: "critical" | "high" | "medium" | "low" | "info"
-  - claim: one-sentence statement (max 2000 chars)
-  - subject?: one exact subject form listed by this kind; omit rather than guess
-  - evidence: REQUIRED non-empty array of {"uri": string, "excerpt"?: string}. Use real identifiers with span://, event://, artifact://, metric://, or finding://. Include a short exact quote in excerpt when available. If nothing is citable, do not emit the finding.
-  - confidence: number 0..1 (0.9+ exact evidence; 0.6-0.8 inferred pattern; <0.5 speculative)
-  - rationale?: one or two reasoning sentences
-  - recommended_action?: concrete imperative change; omit for descriptive findings
-
-Unknown fields are rejected. Do not emit area; the factory assigns it. Emit [] when there are no findings. Never fabricate evidence.`;
-/** Convert raw citations into the public finding evidence envelope. */
-function evidenceRefsFromRawFinding(finding) {
-	return finding.evidence.map(({ uri, excerpt }) => ({
-		kind: evidenceKindFromUri(uri),
-		uri,
-		excerpt
-	}));
-}
-function parseRawFinding(row, log) {
-	return parseFindingWithSchema(RawAnalystFindingSchema, row, log);
-}
-function parseFindingWithSchema(schema, row, log) {
-	const result = schema.safeParse(row);
-	if (result.success) return result.data;
-	if (typeof row === "string") {
-		const coerced = coerceJson(row);
-		if (coerced !== void 0) {
-			const retry = schema.safeParse(coerced);
-			if (retry.success) return retry.data;
-		}
-	}
-	log?.("finding rejected: schema failure", { issues: result.error.issues.map((i) => ({
-		path: i.path.join("."),
-		code: i.code,
-		message: i.message
-	})) });
-	return null;
-}
-function evidenceKindFromUri(uri) {
-	if (uri.startsWith("span://")) return "span";
-	if (/^trace:\/\/[^/]+\/span\/[^/]+$/.test(uri)) return "span";
-	if (uri.startsWith("event://")) return "event";
-	if (uri.startsWith("finding://")) return "finding";
-	if (uri.startsWith("metric://")) return "metric";
-	return "artifact";
-}
-//#endregion
-//#region src/analyst/structure-findings.ts
-/**
-* `structureFindings` — the deferred structuring pass (DSPy TwoStepAdapter /
-* HALO `synthesize_traces` analog). The agentic actor reasons FREE-FORM and
-* emits a prose `report` (which any model does reliably); this separate, cheap
-* call's ONLY job is to turn that report into `AnalystFinding[]`. Decoupling
-* reasoning from structuring is what makes the SEMANTIC findings model-agnostic
-* — the reasoning model never has to satisfy a strict typed-array contract
-* while it diagnoses.
-*
-* Forgiving: the response runs through `coerceToFindingRows` (de-fence, lift
-* single→array) before Zod, and on a zero-finding extraction from a substantive
-* report it reasks ONCE with the schema restated. Returns a typed outcome so a
-* legitimate "nothing to report" is distinguishable from a failed extraction
-* (no silent empty).
-*/
-const SYSTEM = [
-	"You convert a free-form trace-analysis report into a STRICT JSON array of findings.",
-	"Output ONLY the JSON array — no prose, no code fences.",
-	RAW_FINDING_SCHEMA_PROMPT,
-	"Omit subject when the report does not contain an exact valid locus.",
-	"If the report asserts NO problems, output exactly []."
-].join(" ");
-function buildRows(raw, opts) {
-	const rows = coerceToFindingRows(raw);
-	const out = [];
-	for (const row of rows) {
-		const parsed = parseRawFinding(row);
-		if (!parsed) continue;
-		const callbackResult = opts.processRow ? opts.processRow(parsed) : parsed;
-		if (!callbackResult) continue;
-		const processed = parseRawFinding(callbackResult);
-		if (!processed) continue;
-		out.push(makeFinding({
-			analyst_id: opts.analystId,
-			area: opts.area,
-			subject: processed.subject,
-			claim: processed.claim,
-			rationale: processed.rationale,
-			severity: processed.severity,
-			confidence: processed.confidence,
-			evidence_refs: evidenceRefsFromRawFinding(processed),
-			recommended_action: processed.recommended_action,
-			...opts.findingMetadata ? { metadata: { ...opts.findingMetadata } } : {}
-		}));
-	}
-	return out;
-}
-async function structureFindings(opts) {
-	const maxReasks = opts.maxReasks ?? 1;
-	if (!Number.isSafeInteger(maxReasks) || maxReasks < 0) throw new RangeError("structureFindings: maxReasks must be a non-negative safe integer");
-	const llm = {
-		baseUrl: opts.baseUrl,
-		apiKey: opts.apiKey,
-		fetch: opts.fetchImpl
-	};
-	const costLedger = opts.costLedger ?? new CostLedger();
-	let user = `TRACE-ANALYSIS REPORT:\n${opts.report}\n\nReturn the findings JSON array.`;
-	for (let attempt = 0; attempt <= maxReasks; attempt++) {
-		const request = {
-			model: opts.model,
-			messages: [{
-				role: "system",
-				content: SYSTEM
-			}, {
-				role: "user",
-				content: user
-			}],
-			maxTokens: opts.maxTokens ?? 2e3
-		};
-		const paid = await costLedger.runPaidCall({
-			channel: "analyst",
-			phase: opts.costPhase ?? "analyst.structure-findings",
-			actor: "structure-findings",
-			model: opts.model,
-			signal: opts.signal,
-			maximumCharge: maximumChargeForLlmRequest(request, llm),
-			tags: {
-				...opts.costTags,
-				analystId: opts.analystId,
-				attempt: String(attempt)
-			},
-			execute: (signal, callId) => callLlm(request, {
-				...llm,
-				signal,
-				idempotencyKey: callId
-			}),
-			receipt: costReceiptFromLlm,
-			receiptFromError: costReceiptFromLlmError
-		});
-		if (!paid.succeeded) throw paid.error;
-		const findings = buildRows(paid.value.content.trim(), opts);
-		if (findings.length > 0) return {
-			findings,
-			outcome: "ok"
-		};
-		if (opts.report.trim().length < 200) return {
-			findings: [],
-			outcome: "ok"
-		};
-		user = `${user}\n\nThat produced no valid findings. The report DOES describe issues — re-extract them as the strict JSON array described in the system prompt. Output ONLY the array.`;
-	}
-	return {
-		findings: [],
-		outcome: "extraction_failed"
-	};
-}
-//#endregion
-//#region src/analyst/kind-factory.ts
-/**
-* Build an `Analyst<TraceAnalysisStore>` from a kind spec.
-*
-* Lifts the Ax pipeline once at registration time so the registry
-* gets a stateless analyst. The Ax agent is freshly constructed per
-* `analyze()` call (the agent carries chat-log + usage state we don't
-* want shared across analyst runs).
-*/
-function createTraceAnalystKind(spec, opts) {
-	rejectRemovedKindOptions(spec);
-	const version = opts.versionSuffix ? `${spec.version}+${opts.versionSuffix}` : spec.version;
-	const model = resolveAnalystModel(opts.ai, opts.model);
-	const minimumEvidenceCitations = spec.minimumEvidenceCitations ?? 1;
-	if (!Number.isInteger(minimumEvidenceCitations) || minimumEvidenceCitations < 1) throw new TypeError("minimumEvidenceCitations must be a positive integer");
-	const settlementTimeoutMs = validateUsageSettlementTimeout(opts.settlementTimeoutMs);
-	const maxOutputTokens = spec.maxOutputTokens ?? 4096;
-	const aiIdentity = opts.aiIdentity === void 0 ? null : snapshotExactExecutionComponentIdentity(opts.aiIdentity, "createTraceAnalystKind aiIdentity");
-	return {
-		id: spec.id,
-		description: spec.description,
-		inputKind: "trace-store",
-		cost: {
-			...spec.cost,
-			settlement_timeout_ms: settlementTimeoutMs
-		},
-		version,
-		executionConfig: {
-			kind: "trace-analyst",
-			model,
-			ai_identity: aiIdentity,
-			actor_description_digest: hashCanonical(spec.actorDescription.trim()),
-			max_subqueries: spec.subqueries?.maxCalls ?? 0,
-			max_parallel_subqueries: spec.subqueries?.maxParallel ?? 2,
-			max_turns: spec.maxTurns ?? 12,
-			max_runtime_chars: spec.maxRuntimeChars ?? 6e3,
-			max_output_tokens: maxOutputTokens,
-			minimum_evidence_citations: minimumEvidenceCitations,
-			require_structured_findings: spec.requireStructuredFindings ?? false,
-			prepare_context: spec.prepareContext === void 0 ? "disabled" : "version-bound",
-			post_process: spec.postProcess === void 0 ? "disabled" : "version-bound",
-			recovery: opts.recovery === void 0 ? null : {
-				base_url: opts.recovery.baseUrl,
-				model: opts.recovery.model ?? model,
-				api_key_provided: opts.recovery.apiKey !== void 0,
-				fetch_implementation: opts.recovery.fetchImpl === void 0 ? "global" : "version-bound"
-			},
-			settlement_timeout_ms: settlementTimeoutMs
-		},
-		async analyze(store, ctx) {
-			const costLedger = ctx.costLedger ?? new CostLedger(ctx.budgetUsd);
-			const costTags = {
-				...ctx.tags ?? {},
-				analystId: spec.id,
-				...ctx.correlationId ? { analystRunId: ctx.correlationId } : {}
-			};
-			const meteredAi = meterAxChatService(opts.ai, {
-				ledger: costLedger,
-				actor: spec.id,
-				maxOutputTokens,
-				defaultModel: model,
-				phase: ctx.costPhase,
-				signal: ctx.signal,
-				tags: costTags
-			});
-			try {
-				const preparedContext = await spec.prepareContext?.(store, ctx);
-				if (preparedContext !== void 0 && typeof preparedContext !== "string") throw new TypeError(`Trace analyst '${spec.id}' prepareContext must return a string`);
-				const tools = preparedContext === void 0 ? spec.buildTools(store) : [];
-				const analysisMode = preparedContext === void 0 ? "tool-loop" : "prepared-context";
-				const maxSubqueries = spec.subqueries?.maxCalls ?? 0;
-				const maxParallel = spec.subqueries?.maxParallel ?? 2;
-				const priorContext = renderPriorFindings(ctx.priorFindings);
-				const upstreamContext = renderUpstreamFindings(ctx.upstreamFindings);
-				const actorDescription = spec.actorDescription.trim() + priorContext + upstreamContext + "\n\n" + RAW_FINDING_SCHEMA_PROMPT + (minimumEvidenceCitations > 1 ? `\n\nThis kind requires at least ${minimumEvidenceCitations} evidence citations per finding; rows with fewer are rejected.` : "") + "\n\nFirst write `report`: a concise free-form prose diagnosis of what the traces show — what succeeded, what was suboptimal or failed — with concrete trace ids and numbers. THEN return the structured `findings` array (it MAY be empty when there is nothing to report).";
-				ctx.log?.(`analyst.kind ${spec.id} forward`, {
-					max_subqueries: maxSubqueries,
-					tool_count: tools.length,
-					analysis_mode: analysisMode,
-					prepared_context_chars: preparedContext?.length ?? 0,
-					tags: ctx.tags
-				});
-				const completed = await runTraceAnalysisLoop({
-					id: spec.id,
-					description: spec.description,
-					prompt: actorDescription,
-					question: deriveQuestion(ctx, spec),
-					ai: meteredAi,
-					model,
-					tools,
-					findingType: "object",
-					maxSubqueries,
-					maxParallelSubqueries: maxParallel,
-					maxTurns: spec.maxTurns ?? 12,
-					maxRuntimeChars: spec.maxRuntimeChars ?? 6e3,
-					...preparedContext !== void 0 ? { context: preparedContext } : {},
-					...ctx.signal ? { signal: ctx.signal } : {}
-				});
-				const { report, findings: submittedFindings } = completed;
-				const expectedSubjects = KIND_EXPECTED_SUBJECTS[spec.id];
-				const out = [];
-				const rawRows = submittedFindings;
-				let rejectedWrongKind = 0;
-				let rejectedInsufficientEvidence = 0;
-				const processRow = (parsed) => {
-					const callbackResult = spec.postProcess ? spec.postProcess(parsed, ctx) : parsed;
-					if (!callbackResult) return null;
-					const postProcessed = parseRawFinding(callbackResult, ctx.log);
-					if (!postProcessed) return null;
-					if (expectedSubjects && postProcessed.subject !== void 0) {
-						const parsedSubject = parseFindingSubject(postProcessed.subject);
-						if (parsedSubject === null) {
-							ctx.log?.("finding rejected: subject failed to parse", {
-								kind: spec.id,
-								subject: postProcessed.subject
-							});
-							rejectedWrongKind += 1;
-							return null;
-						}
-						if (!expectedSubjects.includes(parsedSubject.kind)) {
-							ctx.log?.("finding rejected: subject variant not allowed for this kind", {
-								kind: spec.id,
-								subject_kind: parsedSubject.kind,
-								subject: postProcessed.subject,
-								allowed: expectedSubjects
-							});
-							rejectedWrongKind += 1;
-							return null;
-						}
-					}
-					const distinctEvidenceCitations = new Set(postProcessed.evidence.map((citation) => citation.uri.trim())).size;
-					if (distinctEvidenceCitations < minimumEvidenceCitations) {
-						ctx.log?.("finding rejected: insufficient evidence citations", {
-							kind: spec.id,
-							required: minimumEvidenceCitations,
-							received: postProcessed.evidence.length,
-							distinct: distinctEvidenceCitations
-						});
-						rejectedInsufficientEvidence += 1;
-						return null;
-					}
-					return postProcessed;
-				};
-				for (const row of rawRows) {
-					const parsed = parseRawFinding(row, ctx.log);
-					if (!parsed) continue;
-					const postProcessed = processRow(parsed);
-					if (!postProcessed) continue;
-					out.push(toAnalystFinding(spec, version, postProcessed, {
-						analysis_mode: analysisMode,
-						analysis_turn_count: completed.turnCount
-					}));
-				}
-				ctx.log?.(`analyst.kind ${spec.id} done`, {
-					emitted: rawRows.length,
-					accepted: out.length,
-					rejected_wrong_subject: rejectedWrongKind,
-					rejected_insufficient_evidence: rejectedInsufficientEvidence
-				});
-				if (out.length === 0 && report.trim().length >= 200) {
-					if (opts.recovery) {
-						const wrongKindBefore = rejectedWrongKind;
-						const insufficientEvidenceBefore = rejectedInsufficientEvidence;
-						const recovered = await structureFindings({
-							report,
-							analystId: spec.id,
-							area: spec.area,
-							model: opts.recovery.model ?? model,
-							baseUrl: opts.recovery.baseUrl,
-							apiKey: opts.recovery.apiKey,
-							fetchImpl: opts.recovery.fetchImpl,
-							costLedger,
-							costPhase: ctx.costPhase,
-							costTags,
-							signal: ctx.signal,
-							maxTokens: Math.min(maxOutputTokens, 2e3),
-							processRow,
-							findingMetadata: { kind_version: version }
-						});
-						out.push(...recovered.findings);
-						ctx.log?.(`analyst.kind ${spec.id} recovery`, {
-							outcome: recovered.outcome,
-							recovered: recovered.findings.length,
-							rejected_wrong_subject: rejectedWrongKind - wrongKindBefore,
-							rejected_insufficient_evidence: rejectedInsufficientEvidence - insufficientEvidenceBefore
-						});
-					}
-					if (out.length === 0) {
-						if (spec.requireStructuredFindings) throw new Error(`Trace analyst '${spec.id}' produced no valid structured findings after ${completed.turnCount} turns: ${truncateForContext(report, 600)}`);
-						const fallback = processRow({
-							claim: "Analyst produced a diagnosis but no structured findings — see report.",
-							rationale: report.slice(0, 1500),
-							severity: "info",
-							confidence: .3,
-							evidence: [{
-								uri: "report://summary",
-								excerpt: report.slice(0, 2e3)
-							}]
-						});
-						if (fallback) out.push(toAnalystFinding(spec, version, fallback, {
-							analysis_mode: analysisMode,
-							analysis_turn_count: completed.turnCount,
-							outcome: "extraction_failed"
-						}));
-						else throw new Error(`Trace analyst '${spec.id}' produced a substantive report, but no finding satisfied its acceptance rules`);
-					}
-				}
-				return out;
-			} finally {
-				const usage = await settleUsageReceiptFromCostLedger(costLedger, {
-					tags: {
-						analystId: spec.id,
-						...ctx.correlationId ? { analystRunId: ctx.correlationId } : {}
-					},
-					timeoutMs: settlementTimeoutMs
-				});
-				if (!usage.settled) ctx.log?.(`analyst.kind ${spec.id} provider settlement timed out`, {
-					pending_calls: usage.pendingCalls,
-					timeout_ms: settlementTimeoutMs
-				});
-				ctx.recordUsage?.(usage.receipt);
-			}
-		}
-	};
-}
-function rejectRemovedKindOptions(spec) {
-	const supplied = spec;
-	for (const [removed, replacement] of [
-		["recursion", "subqueries"],
-		["responderDescription", "actorDescription"],
-		["maxDepth", "subqueries"],
-		["maxParallelSubagents", "subqueries.maxParallel"],
-		["subagentDescription", "actorDescription"]
-	]) if (removed in supplied) throw new TypeError(`createTraceAnalystKind: '${removed}' is unsupported; use '${replacement}'`);
-}
-function deriveQuestion(ctx, spec) {
-	const focus = ctx.tags?.focus?.trim();
-	const task = `Analyze this trace dataset with the available tools and report ${spec.area} findings. ${spec.description}`;
-	return focus ? `${task} Focus: ${focus}.` : task;
-}
-function toAnalystFinding(spec, version, raw, metadata = {}) {
-	return makeFinding({
-		analyst_id: spec.id,
-		area: spec.area,
-		subject: raw.subject,
-		claim: raw.claim,
-		rationale: raw.rationale,
-		severity: raw.severity,
-		confidence: raw.confidence,
-		evidence_refs: evidenceRefsFromRawFinding(raw),
-		recommended_action: raw.recommended_action,
-		metadata: {
-			kind_version: version,
-			...metadata
-		}
-	});
-}
-/**
-* Render a compact prior-findings block the actor reads alongside its
-* brief. Each row is one line so the actor can scan dozens cheaply.
-* The kind's prompt instructs the actor to (a) check whether a new
-* cluster matches a prior `finding_id` (carry the id forward via
-* `id_basis` to keep diffs stable) and (b) raise severity / confidence
-* when a prior finding has reappeared without remediation.
-*
-* Returns the empty string when there are no prior findings — most
-* runs are "first-of-its-kind" and the prompt stays unchanged.
-*
-* Exported for tests + for consumers that build their own actor
-* prompts (e.g. specialized analysts living outside the default kinds).
-*/
-function renderPriorFindings(prior) {
-	if (!prior || prior.length === 0) return "";
-	const MAX_ROWS = 40;
-	const rows = prior.slice(0, MAX_ROWS).map((f) => {
-		const subject = f.subject ? ` [${f.subject}]` : "";
-		return `  - id=${f.finding_id} ${f.severity}${subject} ${truncateForContext(f.claim, 160)}`;
-	});
-	const overflow = prior.length > MAX_ROWS ? `\n  ... +${prior.length - MAX_ROWS} more prior findings (older history truncated)` : "";
-	return [
-		"",
-		"",
-		"PRIOR FINDINGS (from a previous run on related data):",
-		"When the work you do now matches a row below, REUSE the `finding_id` (pass it as `id_basis`) so the cross-run diff stays stable.",
-		"A finding that reappears with no remediation evidence SHOULD raise its `confidence` and may justify a higher `severity`.",
-		...rows,
-		overflow
-	].filter(Boolean).join("\n");
-}
-/** Render findings produced earlier in this same registry run. */
-function renderUpstreamFindings(upstream) {
-	if (!upstream || upstream.length === 0) return "";
-	const MAX_ROWS = 40;
-	const rows = upstream.slice(0, MAX_ROWS).map((finding) => {
-		const subject = finding.subject ? ` [${finding.subject}]` : "";
-		const action = finding.recommended_action ? ` action=${truncateForContext(finding.recommended_action, 120)}` : "";
-		const evidence = finding.evidence_refs[0] ? ` evidence=${truncateForContext(finding.evidence_refs[0].uri, 120)}` : "";
-		return `  - id=${finding.finding_id} source=${finding.analyst_id} ${finding.severity}${subject} claim=${truncateForContext(finding.claim, 160)}${action}${evidence}`;
-	});
-	const overflow = upstream.length > MAX_ROWS ? `\n  ... +${upstream.length - MAX_ROWS} more upstream findings (truncated)` : "";
-	return [
-		"",
-		"",
-		"UPSTREAM FINDINGS (produced earlier in this same registry run):",
-		"Use these as intermediate evidence. Build on them instead of repeating the same diagnosis, and cite a dependency with `finding://<id>`.",
-		...rows,
-		overflow
-	].filter(Boolean).join("\n");
-}
-function truncateForContext(s, max) {
-	if (s.length <= max) return s;
-	return `${s.slice(0, max - 1).trimEnd()}…`;
-}
-//#endregion
 //#region src/analyst/kinds/control-integrity.ts
 const ANALYST_ID = "control-integrity";
 function shown(value) {
@@ -2023,95 +622,39 @@ var ControlIntegrityAnalyst = class {
 	}
 };
 const CONTROL_INTEGRITY_ANALYST = new ControlIntegrityAnalyst();
-//#endregion
-//#region src/analyst/tool-groups.ts
-const TOOL_NAMES_BY_GROUP = {
-	all: /* @__PURE__ */ new Set(),
-	discovery: /* @__PURE__ */ new Set([
-		"getDatasetOverview",
-		"queryTraces",
-		"countTraces"
-	]),
-	discoveryAndRead: /* @__PURE__ */ new Set([
-		"getDatasetOverview",
-		"queryTraces",
-		"countTraces",
-		"viewTrace",
-		"viewSpans"
-	]),
-	discoveryAndSearch: /* @__PURE__ */ new Set([
-		"getDatasetOverview",
-		"queryTraces",
-		"countTraces",
-		"searchTrace",
-		"searchSpan"
-	]),
-	targeted: /* @__PURE__ */ new Set([
-		"getDatasetOverview",
-		"queryTraces",
-		"viewSpans",
-		"searchSpan"
-	]),
-	singleTrace: /* @__PURE__ */ new Set([
-		"getDatasetOverview",
-		"viewTrace",
-		"viewSpans",
-		"searchTrace",
-		"searchSpan"
-	])
-};
-/**
-* Build the tool set for a named group bound to a specific trace store.
-*
-* `all` returns every tool. Other groups filter `buildTraceAnalystTools`
-* by name to the documented subset. An unrecognised group name throws —
-* silently returning all tools would defeat the cost-control point.
-*/
-function buildTraceToolsForGroup(group, store) {
-	const all = buildTraceAnalystTools({ store });
-	if (group === "all") return all;
-	const allow = TOOL_NAMES_BY_GROUP[group];
-	if (!allow) throw new Error(`unknown trace tool group: ${group}`);
-	return all.filter((tool) => allow.has(tool.name));
-}
 const FAILURE_MODE_KIND_SPEC = {
 	id: "failure-mode",
 	description: "Clusters trace-dataset failures into distinct failure modes with cited evidence and a short recommended action.",
 	area: "failure-mode",
 	version: "1.2.0",
-	actorDescription: `You are a failure-mode classifier for an OTLP trace dataset. Your job is to identify the **distinct ways agents failed** in this dataset, not to grade individual runs.
+	instructions: `You are a failure-mode classifier for an OTLP trace dataset. Your job is to identify the **distinct ways agents failed** in this dataset, not to grade individual runs.
 
 ${findingSubjectGrammarPromptFor("failure-mode")}
 
 DISCOVERY → CLUSTER → CITE protocol:
 
-1. Call \`traces.getDatasetOverview({})\` first. Use \`has_errors\`, \`models\`, \`agent_names\`, \`tools\`, and \`sample_trace_ids\` to size the failure surface.
-2. Use \`traces.queryTraces({ filters: { has_errors: true }, limit })\` to pull error-bearing traces. Combine with \`traces.countTraces\` to see what fraction of the dataset failed.
-3. For each candidate failure cluster, use \`traces.searchTrace\` with regex like \`STATUS_CODE_ERROR\`, \`MaxTurnsExceeded\`, \`assertion\`, \`unauthorized\`, \`timeout\`, \`429\`, \`5\\d\\d\`, the agent's specific error strings, or the names of its tools. Pull one or two representative traces per cluster, **not all** of them.
+1. Call \`getDatasetOverview({})\` first. Use \`has_errors\`, \`models\`, \`agent_names\`, \`tools\`, and \`sample_trace_ids\` to size the failure surface.
+2. Use \`queryTraces(filters={"has_errors": true}, limit=...)\` to pull error-bearing traces. Combine with \`countTraces\` to see what fraction of the dataset failed.
+3. For each candidate failure cluster, use \`searchTrace\` with regex like \`STATUS_CODE_ERROR\`, \`MaxTurnsExceeded\`, \`assertion\`, \`unauthorized\`, \`timeout\`, \`429\`, \`5\\d\\d\`, the agent's specific error strings, or the names of its tools. Pull one or two representative traces per cluster, **not all** of them.
 4. **Cluster, do not enumerate.** Two failures with the same root cause should be ONE finding citing both traces, not two findings. The point of this analyst is to compress N runs into K modes.
 5. For each defensible cluster, emit ONE finding. Use a lowercase cluster label matching the subject grammar ("tool-call-loop", "auth-revoked-mid-run", ...). Rate it critical when it blocks the run, high when the run finishes degraded, and medium when it slows convergence. Cite representative spans and include exact error, payload, or contradictory-output quotes. Use confidence 0.85+ when multiple traces show the same shape, 0.6-0.8 for a single-trace inference, and <0.5 for speculation. Keep the imperative fix idea short; the improvement analyst expands it.
 
 If the dataset has no failures, return an empty findings array — do NOT pad with low-confidence speculation.
 
-**Use subqueries over loaded evidence.** After the first scan, load representative span excerpts for each candidate cluster. Then send one bounded \`llmQuery\` per cluster in one batch, including the exact excerpts and asking it to classify the root cause. Subqueries cannot call trace tools. Merge or split clusters yourself from their classifications and the cited source evidence.
-
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.
-- Reuse runtime variables across turns; don't recompute.`,
-	buildTools: (store) => buildTraceToolsForGroup("all", store),
-	subqueries: {
-		maxCalls: 8,
-		maxParallel: 4
-	},
-	maxTurns: 24,
-	cost: { kind: "llm" }
+**Use subqueries over loaded evidence.** After the first scan, load representative span excerpts for each candidate cluster. Then send one bounded \`llm_query\` per cluster in one batch, including the exact excerpts and asking it to classify the root cause. Subqueries cannot call trace tools. Merge or split clusters yourself from their classifications and the cited source evidence.`,
+	toolGroup: "all",
+	limits: {
+		maxLlmCalls: 8,
+		maxIterations: 24,
+		maxToolCalls: 64
+	}
 };
 const IMPROVEMENT_KIND_SPEC = {
 	id: "improvement",
 	description: "Converts upstream failure / gap / poisoning findings into concrete locus-named edits (prompt, tool-doc, RAG, scaffolding) with leverage grades.",
 	area: "improvement",
 	version: "1.2.0",
-	actorDescription: `You are a self-improvement analyst. Your job is to propose **concrete, locus-named edits** the agent's runtime should adopt to fix the failure modes, knowledge gaps, and poisonings present in this dataset.
+	instructions: `You are a self-improvement analyst. Your job is to propose **concrete, locus-named edits** the agent's runtime should adopt to fix the failure modes, knowledge gaps, and poisonings present in this dataset.
 
 Upstream analysts have already classified the problems. Your job is to convert each problem into a *change to make* and grade its expected leverage. Each finding is one proposed edit.
 
@@ -2119,7 +662,7 @@ ${findingSubjectGrammarPromptFor("improvement")}
 
 DISCOVERY → CANDIDATE-FIXES → COMPETE → CITE protocol:
 
-1. \`traces.getDatasetOverview({})\` first. Note the agents, tools, and any system-prompt fingerprints (look for the prompt text echoed in early spans).
+1. \`getDatasetOverview({})\` first. Note the agents, tools, and any system-prompt fingerprints (look for the prompt text echoed in early spans).
 2. For each high-severity failure pattern, generate 2-3 candidate fixes. Real candidate axes:
    - **System-prompt edit** — add an instruction, remove a misleading one, restructure precedence
    - **Tool description edit** — rewrite a tool's description so the agent picks it correctly / passes valid args
@@ -2131,33 +674,29 @@ DISCOVERY → CANDIDATE-FIXES → COMPETE → CITE protocol:
    - **Skill / MCP / hook / subagent** — change the reusable profile component responsible for the behavior
    - **Workflow / rollout policy** — change orchestration, budget, sampling, or stopping behavior
    - **Code** — change an implementation path when profile edits cannot repair the behavior
-3. **Compare candidate fixes with bounded subqueries.** Load the representative failure excerpts, then send one \`llmQuery\` per candidate-fix axis the same evidence. Ask for likely effect, side effects, and implementation scope. Subqueries cannot call trace tools; trace ids alone are insufficient context.
+3. **Compare candidate fixes with bounded subqueries.** Load the representative failure excerpts, then send one \`llm_query\` per candidate-fix axis the same evidence. Ask for likely effect, side effects, and implementation scope. Subqueries cannot call trace tools; trace ids alone are insufficient context.
 4. After the comparisons return, **pick the winning candidate per cluster** based on expected effect and risk, then emit ONE finding. Keep the alternatives and rejection reasons in the rationale so the recommendation is auditable.
 5. **Cross-reference upstream findings.** Cite prior failure-mode or knowledge-gap findings as \`finding://<prior-finding-id>\`. This builds the dependency graph that lets the dashboard show "fix #X resolves failure modes A, B, C."
 
 For each winning recommendation, emit ONE finding. Use one exact locus from the subject grammar and state the edit in one sentence. Match leverage to the source failure's severity; use medium for quality-of-life changes and info for cleanup with no behavioral effect. Cite the targeted \`finding://<id>\` when available and the most representative span when useful. Quote the problem being fixed. Use confidence 0.85+ for a mechanical fix to a well-evidenced failure, 0.6-0.8 when judgment is required, and <0.5 for speculation. Explain in at most two sentences why this candidate beat its alternatives. The recommended action must be the literal diff, quoted replacement, tool description, or setting change.
 
-If no upstream failure findings exist in this run, derive your own from the trace dataset using the failure-mode protocol inline (\`searchTrace\` for STATUS_CODE_ERROR / MaxTurnsExceeded / etc.). But prefer to consume upstream findings when present — the kinds are designed to chain.
-
-Do NOT propose a fix you cannot defend with evidence. "Tighten the prompt" is not a finding; "Add 'When the user asks for X, always Y' to the system prompt section "request-classification"" is.
+If no upstream failure findings exist in this run, derive your own from the trace dataset using the failure-mode protocol inline (\`searchTrace\` for STATUS_CODE_ERROR / MaxTurnsExceeded / etc.). Prefer upstream findings when present because the analysts are designed to chain.
 
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.`,
-	buildTools: (store) => buildTraceToolsForGroup("all", store),
-	subqueries: {
-		maxCalls: 8,
-		maxParallel: 4
-	},
-	maxTurns: 30,
-	maxRuntimeChars: 12e3,
-	cost: { kind: "llm" }
+Do NOT propose a fix you cannot defend with evidence. "Tighten the prompt" is not a finding; "Add 'When the user asks for X, always Y' to the system prompt section "request-classification"" is.`,
+	toolGroup: "all",
+	limits: {
+		maxLlmCalls: 8,
+		maxIterations: 30,
+		maxToolCalls: 80,
+		maxOutputChars: 12e3
+	}
 };
 const KNOWLEDGE_GAP_KIND_SPEC = {
 	id: "knowledge-gap",
 	description: "Identifies missing or stale pieces of knowledge — primarily against the agent-knowledge wiki — and attributes each to the runtime layer (wiki page, claim, raw source, websearch, tool-doc, system-prompt, memory) that should have held it.",
 	area: "knowledge-gap",
 	version: "1.2.0",
-	actorDescription: `You are a knowledge-gap analyst for an OTLP trace dataset. Your job is to identify the **specific pieces of information the agent lacked, or that were stale**, that caused poor decisions.
+	instructions: `You are a knowledge-gap analyst for an OTLP trace dataset. Your job is to identify the **specific pieces of information the agent lacked, or that were stale**, that caused poor decisions.
 
 The agent under analysis maintains a curated knowledge base via \`@tangle-network/agent-knowledge\` — a wiki of \`KnowledgePage\`s with raw source anchors, claims, and relations. The primary expected store of agent-knowable facts IS that wiki. A "knowledge gap" is anything the agent had to discover or guess at run-time that the wiki should have held — or an outdated/contradictory fact the agent picked up from a non-wiki source.
 
@@ -2165,7 +704,7 @@ ${findingSubjectGrammarPromptFor("knowledge-gap")}
 
 DISCOVERY → ATTRIBUTE-TO-LAYER → CITE protocol:
 
-1. \`traces.getDatasetOverview({})\` first. Note which agents, tools, and models appear.
+1. \`getDatasetOverview({})\` first. Note which agents, tools, and models appear.
 2. Pull traces where the agent shows gap signals. The strongest signals are:
    - Self-correction turns ("I assumed X but…", "let me re-check", "actually,")
    - Clarifying-question turns where the agent asked the user something the runtime should have surfaced
@@ -2174,36 +713,32 @@ DISCOVERY → ATTRIBUTE-TO-LAYER → CITE protocol:
    - Web-search calls returning pages dated before a known cutoff for content that changes (versioned APIs, schemas, policies)
    - Agent quoting a tool's docs / system prompt incorrectly because the actual text was insufficient
    - Fabricated identifiers that don't appear in dataset \`sample_trace_ids\`
-   Use \`traces.searchTrace\` with patterns like \`I (don.?t|do not) know\`, \`assumed\`, \`unclear\`, \`could you (clarify|tell me|provide)\`, \`not found\`, \`undefined\`, \`unknown\`, \`null\`, dates older than the analysis window, or the agent's specific clarification phrases.
+   Use \`searchTrace\` with patterns like \`I (don.?t|do not) know\`, \`assumed\`, \`unclear\`, \`could you (clarify|tell me|provide)\`, \`not found\`, \`undefined\`, \`unknown\`, \`null\`, dates older than the analysis window, or the agent's specific clarification phrases.
 3. For each gap, identify the **layer of the runtime that should have prevented it** and use its exact locus from the subject grammar above.
 4. For each defensible gap, emit ONE finding. Use an exact locus from the subject grammar and name the missing or stale knowledge (for example, "wiki has no page on invoice line-item shape; agent re-derived it from raw spans"). Rate it high when it caused failure or a clarifying question, medium for unnecessary turns, and low for minor inefficiency. Cite the span where the question, correction, retrieval miss, or stale result surfaced and quote it exactly. Use confidence 0.85+ when the agent articulated the gap and 0.6-0.8 when inferred. Recommend a concrete wiki edit for an agent-knowledge locus or a prompt/tool-description edit otherwise.
 
-**Compare layers over loaded evidence.** After the first scan, load the exact excerpts behind candidates across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Use one bounded \`llmQuery\` per layer to classify those excerpts. Subqueries cannot call trace tools. Merge their classifications into the final finding set only when the source excerpts support them.
+**Compare layers over loaded evidence.** After the first scan, load the exact excerpts behind candidates across \`agent-knowledge:*\`, \`websearch:outdated\`, \`tool-doc:*\`, \`system-prompt:*\`, and \`memory:*\`. Use one bounded \`llm_query\` per layer to classify those excerpts. Subqueries cannot call trace tools. Merge their classifications into the final finding set only when the source excerpts support them.
 
-Do NOT report a gap that the agent later recovered from cleanly within the same turn — that's resilience, not a gap. Cite the *non-recovery* version when both exist.
-
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.`,
-	buildTools: (store) => buildTraceToolsForGroup("discoveryAndSearch", store),
-	subqueries: {
-		maxCalls: 5,
-		maxParallel: 4
-	},
-	maxTurns: 18,
-	cost: { kind: "llm" }
+Do NOT report a gap that the agent later recovered from cleanly within the same turn. That is resilience, not a gap. Cite the non-recovery version when both exist.`,
+	toolGroup: "discoveryAndSearch",
+	limits: {
+		maxLlmCalls: 5,
+		maxIterations: 18,
+		maxToolCalls: 48
+	}
 };
 const KNOWLEDGE_POISONING_KIND_SPEC = {
 	id: "knowledge-poisoning",
 	description: "Identifies confident-but-wrong actions caused by stale memory, contradicting RAG, deprecated tool docs, or outdated system-prompt instructions.",
 	area: "knowledge-poisoning",
 	version: "1.2.0",
-	actorDescription: `You are a knowledge-poisoning analyst for an OTLP trace dataset. Your job is to identify cases where the agent **confidently used wrong information** — not where it lacked information (that's the knowledge-gap analyst).
+	instructions: `You are a knowledge-poisoning analyst for an OTLP trace dataset. Your job is to identify cases where the agent **confidently used wrong information** — not where it lacked information (that's the knowledge-gap analyst).
 
 ${findingSubjectGrammarPromptFor("knowledge-poisoning")}
 
 DISCOVERY → DUAL-VERIFY → CITE protocol:
 
-1. \`traces.getDatasetOverview({})\` first. Identify the agents, models, and tools.
+1. \`getDatasetOverview({})\` first. Identify the agents, models, and tools.
 2. Pull traces where the agent's confident action was later contradicted. Strongest signals:
    - Agent stated a fact in one span; a later span surfaced contradictory evidence; the agent then proceeded anyway or fabricated reconciliation.
    - Tool call with stale arguments (an id that no longer exists, an API shape that changed).
@@ -2211,28 +746,24 @@ DISCOVERY → DUAL-VERIFY → CITE protocol:
    - Web-search result the agent cited that returned an outdated page; agent treated it as canonical.
    - System-prompt instruction the agent followed that ground-truth evidence in the trace contradicts (e.g. prompt says "use endpoint A"; tool reply says "endpoint A deprecated, use B").
    - Repeated wrong-shape parsing despite the tool's actual output proving the shape.
-3. Use \`traces.searchTrace\` with regex on phrases like \`actually\`, \`turns out\`, \`previously assumed\`, \`old version\`, \`deprecated\`, \`updated to\`, \`now uses\`, or specific entity names you suspect have changed.
+3. Use \`searchTrace\` with regex on phrases like \`actually\`, \`turns out\`, \`previously assumed\`, \`old version\`, \`deprecated\`, \`updated to\`, \`now uses\`, or specific entity names you suspect have changed.
 4. For each candidate poisoning, **DUAL-VERIFY**:
    - Confirm the agent actually acted on the false belief (cite the span where it did)
    - Confirm the belief is actually false in this trace's own evidence (cite the span that contradicts it)
-   Only emit a finding when both halves are nailed down. If you can only nail one, drop it — single-evidence poisoning findings are too speculative to be useful.
+   Only emit a finding when both halves are supported. If you can only support one, drop it because single-evidence poisoning findings are too speculative to be useful.
 
-**Independently assess both halves.** Load the action excerpt and contradicting excerpt yourself, then send bounded \`llmQuery\` calls the exact evidence for "did the agent act?" and "does the trace contradict the belief?" Subqueries cannot call trace tools. Accept a poisoning only when both assessments and the source excerpts support it.
+**Independently assess both halves.** Load the action excerpt and contradicting excerpt yourself, then send bounded \`llm_query\` calls the exact evidence for "did the agent act?" and "does the trace contradict the belief?" Subqueries cannot call trace tools. Accept a poisoning only when both assessments and the source excerpts support it.
 
 For each confirmed poisoning, emit ONE finding. Use the source of the false belief as the exact subject. State "agent believed X (from source S); trace evidence shows X is false." Rate it critical for a wrong user-visible action, high when caught internally after significant waste, and medium for inefficiency. Cite BOTH the action span and the contradicting span with exact quotes. Use confidence 0.85+ when both halves have exact quotes and 0.6-0.8 when one half is inferred. Recommend the literal source correction: update the wiki claim, invalidate and re-curate the raw source, or replace the stale prompt/tool instruction.
 
-Do NOT report a finding if the agent caught and corrected the false belief in the same turn — that's the system working. Reserve poisoning for cases where the false belief shaped downstream action.
-
-OBSERVABILITY rules:
-- Each non-final turn must emit at least one \`console.log\` for evidence.`,
-	buildTools: (store) => buildTraceToolsForGroup("all", store),
-	subqueries: {
-		maxCalls: 8,
-		maxParallel: 4
+Do NOT report a finding if the agent caught and corrected the false belief in the same turn. Reserve poisoning for cases where the false belief shaped downstream action.`,
+	toolGroup: "all",
+	limits: {
+		maxLlmCalls: 8,
+		maxIterations: 20,
+		maxToolCalls: 64
 	},
-	maxTurns: 20,
-	minimumEvidenceCitations: 2,
-	cost: { kind: "llm" }
+	minimumEvidenceCitations: 2
 };
 //#endregion
 //#region src/analyst/kinds/index.ts
@@ -3820,20 +2351,14 @@ function selectPriorFindings(source, analystId) {
 }
 //#endregion
 //#region src/analyst/default-registry.ts
-function buildDefaultAnalystRegistry(opts = {}) {
-	const registry = new AnalystRegistry(opts.registry);
-	if (opts.includeBehavioral !== false) registry.register(behavioralAnalyst(opts.behavioral));
-	if (opts.ai) {
-		const kinds = opts.kinds ?? DEFAULT_TRACE_ANALYST_KINDS;
-		for (const spec of kinds) registry.register(createTraceAnalystKind(spec, {
-			ai: opts.ai,
-			model: opts.model,
-			aiIdentity: opts.aiIdentity
-		}));
-	}
+function buildDefaultAnalystRegistry(options = {}) {
+	if (options.definitions && !options.engine) throw new TypeError("buildDefaultAnalystRegistry: definitions require an engine — a definition cannot run without one");
+	const registry = new AnalystRegistry(options.registry);
+	if (options.includeBehavioral !== false) registry.register(behavioralAnalyst(options.behavioral));
+	if (options.engine) for (const definition of options.definitions ?? DEFAULT_TRACE_ANALYST_KINDS) registry.register(createTraceAnalyst(definition, { engine: options.engine }));
 	return registry;
 }
 //#endregion
-export { parseRawFinding as A, parseFindingSubject as B, renderUpstreamFindings as C, RawAnalystEvidenceSchema as D, RAW_FINDING_SCHEMA_PROMPT as E, FINDING_SUBJECT_KINDS as F, createChatClient as G, behavioralAnalyst as H, FINDING_SUBJECT_SYNTAX as I, createAnalystAi as K, FindingSubjectStringSchema as L, coerceToFindingRows as M, stripCodeFences as N, RawAnalystFindingSchema as O, FINDING_SUBJECT_GRAMMAR_PROMPT as P, KIND_EXPECTED_SUBJECTS as R, renderPriorFindings as S, ANALYST_SEVERITIES as T, deriveEfficiencyFindings as U, renderFindingSubject as V, computeTraceMetrics as W, buildTraceToolsForGroup as _, analystFindingDigest as a, emitControlIntegrityFindings as b, completedAnalystReviewQuality as c, validateAnalystReviewDecisions as d, DEFAULT_TRACE_ANALYST_KINDS as f, FAILURE_MODE_KIND_SPEC as g, IMPROVEMENT_KIND_SPEC as h, assertExactRegistryRunOpts as i, coerceJson as j, evidenceRefsFromRawFinding as k, readAnalystReview as l, KNOWLEDGE_GAP_KIND_SPEC as m, AnalystRegistry as n, analystRunDigest as o, KNOWLEDGE_POISONING_KIND_SPEC as p, ExactAnalystRunExecutionError as r, assertUniqueFindingIds as s, buildDefaultAnalystRegistry as t, snapshotAnalystRun as u, CONTROL_INTEGRITY_ANALYST as v, structureFindings as w, createTraceAnalystKind as x, ControlIntegrityAnalyst as y, findingSubjectGrammarPromptFor as z };
+export { createChatClient as C, computeTraceMetrics as S, CONTROL_INTEGRITY_ANALYST as _, analystFindingDigest as a, behavioralAnalyst as b, completedAnalystReviewQuality as c, validateAnalystReviewDecisions as d, DEFAULT_TRACE_ANALYST_KINDS as f, FAILURE_MODE_KIND_SPEC as g, IMPROVEMENT_KIND_SPEC as h, assertExactRegistryRunOpts as i, readAnalystReview as l, KNOWLEDGE_GAP_KIND_SPEC as m, AnalystRegistry as n, analystRunDigest as o, KNOWLEDGE_POISONING_KIND_SPEC as p, ExactAnalystRunExecutionError as r, assertUniqueFindingIds as s, buildDefaultAnalystRegistry as t, snapshotAnalystRun as u, ControlIntegrityAnalyst as v, deriveEfficiencyFindings as x, emitControlIntegrityFindings as y };
 
-//# sourceMappingURL=default-registry-lp5R0lve.js.map
+//# sourceMappingURL=default-registry-BgJJItGr.js.map