@tangle-network/agent-eval 0.217.1 → 0.219.0

package/dist/{default-registry-ClYjq3QE.js → default-registry-BrKmT01n.js}

@@ -2,12 +2,12 @@ import { a as hashCanonical, r as canonicalString } from "./canonical-Dq2hOQ8L.j
 import { t as deepFreezeCanonicalJson } from "./deep-freeze-CurcOQg3.js";
 import { i as makeFinding } from "./types-DqFMNTgK.js";
 import { n as isRecord } from "./json-BhdsJaOQ.js";
-import { G as validateUsageSettlementTimeout, K as snapshotExactExecutionComponentIdentity, O as spanEpochMillis, U as assertValidAnalystUsageReceipt, q as snapshotExactExecutionPlan, t as createTraceAnalyst, z as findingSubjectGrammarPromptFor } from "./kind-factory-Gy4fXixd.js";
+import { G as validateUsageSettlementTimeout, K as snapshotExactExecutionComponentIdentity, O as spanEpochMillis, U as assertValidAnalystUsageReceipt, q as snapshotExactExecutionPlan, t as createTraceAnalyst, z as findingSubjectGrammarPromptFor } from "./kind-factory-BhxbtUsQ.js";
 import { LLM_CONTEXT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_OUTPUT_TOKEN_ATTR_KEYS, TOOL_NAME_ATTR_KEYS } from "./trace-attributes.js";
 import "./otlp-attributes-D9ptWaIJ.js";
-import { _ as combineAbortSignals } from "./llm-client-BshCREn6.js";
+import { _ as combineAbortSignals } from "./llm-client-DXuOTseU.js";
 import { t as executionTrackByLane } from "./execution-tracks-CpgFPpS5.js";
-import { t as analyzeSupervisorRunIntegrity } from "./integrity-DOd9Q86O.js";
+import { t as analyzeSupervisorRunIntegrity } from "./integrity-C8oUeB0g.js";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
 //#region src/feedback-trajectory-review.ts
@@ -1854,306 +1854,338 @@ var ExactAnalystRunExecutionError = class extends Error {
 		this.result = snapshot;
 	}
 };
-async function* executePlanStream(plan) {
+function startPlanRun(plan) {
 	const exact = plan.executionSnapshot !== void 0;
 	if (exact && plan.signal?.aborted) throw abortReason(plan.signal);
-	const correlationId = `ar_${randomUUID().slice(0, 12)}`;
-	const log = plan.log;
-	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const started = Date.now();
 	const timeoutSignal = plan.totalTimeoutMs === null ? void 0 : AbortSignal.timeout(plan.totalTimeoutMs);
-	const runSignal = combineAbortSignals(plan.signal ?? void 0, timeoutSignal);
-	const deadlineMs = plan.totalTimeoutMs === null ? void 0 : started + plan.totalTimeoutMs;
 	const runnable = plan.prepared.filter((candidate) => candidate.input.kind === "present").map((candidate) => candidate.analyst);
-	let remainingUsd = plan.budget.kind === "dynamic" ? plan.budget.policy.totalUsd : void 0;
 	const weights = plan.budget.kind === "dynamic" ? plan.budget.policy.weights : void 0;
 	const totalWeight = weights && plan.budget.kind === "dynamic" && plan.budget.policy.totalUsd != null && !plan.budget.policy.allocate && runnable.length > 0 ? runnable.reduce((sum, analyst) => sum + analystWeight(weights, analyst.id), 0) : void 0;
 	if (totalWeight === 0) throw new Error("BudgetPolicy.weights must allocate positive weight to a runnable analyst");
-	const upstreamFindings = [];
+	return {
+		plan,
+		exact,
+		correlationId: `ar_${randomUUID().slice(0, 12)}`,
+		startedAt: new Date(started).toISOString(),
+		deadlineMs: plan.totalTimeoutMs === null ? void 0 : started + plan.totalTimeoutMs,
+		runSignal: combineAbortSignals(plan.signal ?? void 0, timeoutSignal),
+		runnableCount: runnable.length,
+		totalWeight,
+		remainingUsd: plan.budget.kind === "dynamic" ? plan.budget.policy.totalUsd : void 0,
+		upstreamFindings: [],
+		executions: [],
+		executionFailure: void 0
+	};
+}
+async function* executePlanStream(plan) {
+	const st = startPlanRun(plan);
 	yield snapshotExecutionEvent({
 		type: "run-started",
 		run_id: plan.runId,
-		correlation_id: correlationId,
-		started_at: startedAt,
+		correlation_id: st.correlationId,
+		started_at: st.startedAt,
 		analyst_ids: plan.prepared.map(({ analyst }) => analyst.id),
 		...plan.executionSnapshot === void 0 ? {} : { execution_plan: plan.executionSnapshot }
+	}, st.exact);
+	for (const { analyst, input } of plan.prepared) if ((yield* runAnalyst(st, analyst, input)) === "stop") break;
+	yield* finishRun(st);
+}
+/** Record an analyst skipped because the run was aborted; an exact run fails on it. */
+async function* skipAborted(st, analyst, runSignal, latencyMs) {
+	const { plan, exact } = st;
+	const summary = abortedBeforeStartSummary(analyst, runSignal, latencyMs);
+	st.executions.push({
+		summary,
+		findings: [],
+		budgetDebitUsd: 0
+	});
+	if (latencyMs === void 0) plan.log(`[analyst] skip ${analyst.id} — run aborted`, {
+		runId: plan.runId,
+		reason: summary.reason
+	});
+	yield snapshotExecutionEvent({
+		type: "analyst-skipped",
+		summary
 	}, exact);
-	const executions = [];
-	let executionFailure;
-	for (const { analyst, input } of plan.prepared) {
-		const t0 = Date.now();
-		if (runSignal?.aborted) {
-			const summary = abortedBeforeStartSummary(analyst, runSignal);
-			executions.push({
-				summary,
-				findings: [],
-				budgetDebitUsd: 0
-			});
-			log(`[analyst] skip ${analyst.id} — run aborted`, {
-				runId: plan.runId,
-				reason: summary.reason
-			});
-			yield snapshotExecutionEvent({
-				type: "analyst-skipped",
-				summary
-			}, exact);
-			if (exact) {
-				executionFailure = abortReason(runSignal);
-				break;
-			}
-			continue;
-		}
-		if (input.kind === "missing") {
-			const summary = {
-				analyst_id: analyst.id,
-				status: "skipped",
-				reason: `missing input of kind '${analyst.inputKind}'`,
-				findings_count: 0,
-				latency_ms: 0,
-				usage: zeroUsage()
-			};
-			const execution = {
-				summary,
-				findings: [],
-				budgetDebitUsd: 0
-			};
-			executions.push(execution);
-			log(`[analyst] skip ${analyst.id} — missing input`, {
-				runId: plan.runId,
-				kind: analyst.inputKind
-			});
-			const hookValues = snapshotAfterHookValues(summary, [], exact);
-			try {
-				await waitForHook(plan.hooks.onAfterAnalyze ? () => plan.hooks.onAfterAnalyze?.({
-					analyst,
-					summary: hookValues.summary,
-					findings: hookValues.findings,
-					runId: plan.runId
-				}) : void 0, runSignal);
-			} catch (error) {
-				if (!exact) throw error;
-				executionFailure = error;
-			}
-			yield snapshotExecutionEvent({
-				type: "analyst-skipped",
-				summary
-			}, exact);
-			if (executionFailure !== void 0) break;
-			continue;
-		}
-		const allocatedUsd = plan.executionSnapshot === void 0 ? allocateBudget(plan.budget.kind === "dynamic" ? plan.budget.policy : void 0, {
+	if (exact) {
+		st.executionFailure = abortReason(runSignal);
+		return "stop";
+	}
+	return "next";
+}
+/** An analyst whose input never arrived is skipped; its after-hook still runs. */
+async function* skipMissingInput(st, analyst) {
+	const { plan, exact, runSignal } = st;
+	const summary = {
+		analyst_id: analyst.id,
+		status: "skipped",
+		reason: `missing input of kind '${analyst.inputKind}'`,
+		findings_count: 0,
+		latency_ms: 0,
+		usage: zeroUsage()
+	};
+	st.executions.push({
+		summary,
+		findings: [],
+		budgetDebitUsd: 0
+	});
+	plan.log(`[analyst] skip ${analyst.id} — missing input`, {
+		runId: plan.runId,
+		kind: analyst.inputKind
+	});
+	const hookValues = snapshotAfterHookValues(summary, [], exact);
+	try {
+		await waitForHook(plan.hooks.onAfterAnalyze ? () => plan.hooks.onAfterAnalyze?.({
 			analyst,
-			remainingUsd,
-			runningCount: runnable.length,
-			totalWeight
-		}) : exactPlannedAllocation(plan.executionSnapshot, analyst.id);
-		const budgetCeilingUsd = plan.executionSnapshot === void 0 ? remainingUsd : allocatedUsd;
-		const usageReceipts = [];
-		const contextTags = plan.tags === null ? void 0 : { ...plan.tags };
-		const priorFindings = selectPriorFindings(plan.priorFindings ?? void 0, analyst.id);
-		const chainedFindings = plan.chainFindings && upstreamFindings.length > 0 ? [...upstreamFindings] : void 0;
-		const ctx = {
+			summary: hookValues.summary,
+			findings: hookValues.findings,
+			runId: plan.runId
+		}) : void 0, runSignal);
+	} catch (error) {
+		if (!exact) throw error;
+		st.executionFailure = error;
+	}
+	yield snapshotExecutionEvent({
+		type: "analyst-skipped",
+		summary
+	}, exact);
+	return st.executionFailure !== void 0 ? "stop" : "next";
+}
+/** The context handed to one analyst, with the usage receipts it will record into. */
+function buildAnalystContext(st, analyst) {
+	const { plan, exact } = st;
+	const allocatedUsd = plan.executionSnapshot === void 0 ? allocateBudget(plan.budget.kind === "dynamic" ? plan.budget.policy : void 0, {
+		analyst,
+		remainingUsd: st.remainingUsd,
+		runningCount: st.runnableCount,
+		totalWeight: st.totalWeight
+	}) : exactPlannedAllocation(plan.executionSnapshot, analyst.id);
+	const budgetCeilingUsd = plan.executionSnapshot === void 0 ? st.remainingUsd : allocatedUsd;
+	const usageReceipts = [];
+	const contextTags = plan.tags === null ? void 0 : { ...plan.tags };
+	const priorFindings = selectPriorFindings(plan.priorFindings ?? void 0, analyst.id);
+	const chainedFindings = plan.chainFindings && st.upstreamFindings.length > 0 ? [...st.upstreamFindings] : void 0;
+	const ctx = {
+		runId: plan.runId,
+		correlationId: st.correlationId,
+		deadlineMs: st.deadlineMs,
+		budgetUsd: allocatedUsd,
+		costLedger: plan.costLedger ?? void 0,
+		costPhase: plan.costPhase ?? void 0,
+		chat: plan.chat,
+		tags: contextTags,
+		log: (message, fields) => plan.log(`[${analyst.id}] ${message}`, {
 			runId: plan.runId,
-			correlationId,
-			deadlineMs,
-			budgetUsd: allocatedUsd,
-			costLedger: plan.costLedger ?? void 0,
-			costPhase: plan.costPhase ?? void 0,
-			chat: plan.chat,
-			tags: contextTags,
-			log: (message, fields) => log(`[${analyst.id}] ${message}`, {
-				runId: plan.runId,
-				correlationId,
-				...fields
-			}),
-			signal: runSignal,
-			priorFindings,
-			upstreamFindings: chainedFindings,
-			recordUsage: (receipt) => {
-				if (!exact) {
-					assertValidAnalystUsageReceipt(receipt);
-					usageReceipts.push(receipt);
-					return;
-				}
-				usageReceipts.push(snapshotUsageReceiptOnce(receipt, `AnalystRegistry.runExact analyst "${analyst.id}" usage`));
+			correlationId: st.correlationId,
+			...fields
+		}),
+		signal: st.runSignal,
+		priorFindings,
+		upstreamFindings: chainedFindings,
+		recordUsage: (receipt) => {
+			if (!exact) {
+				assertValidAnalystUsageReceipt(receipt);
+				usageReceipts.push(receipt);
+				return;
 			}
-		};
-		if (exact) {
-			if (contextTags) deepFreezeCanonicalJson(contextTags);
-			if (priorFindings) deepFreezeCanonicalJson(priorFindings);
-			if (chainedFindings) deepFreezeCanonicalJson(chainedFindings);
-			Object.freeze(ctx);
+			usageReceipts.push(snapshotUsageReceiptOnce(receipt, `AnalystRegistry.runExact analyst "${analyst.id}" usage`));
 		}
-		try {
-			await waitForHook(plan.hooks.onBeforeAnalyze ? () => plan.hooks.onBeforeAnalyze?.({
+	};
+	if (exact) {
+		if (contextTags) deepFreezeCanonicalJson(contextTags);
+		if (priorFindings) deepFreezeCanonicalJson(priorFindings);
+		if (chainedFindings) deepFreezeCanonicalJson(chainedFindings);
+		Object.freeze(ctx);
+	}
+	return {
+		ctx,
+		usageReceipts,
+		budgetCeilingUsd
+	};
+}
+/** Run the analyst's own analysis. A failure is recorded; the on-error hook may still contribute findings. */
+async function analyzeOne(st, analyst, value, analystContext, executionSignal) {
+	const { plan, exact, runSignal } = st;
+	let findings;
+	let lifecycleFailure;
+	let analysisFailure;
+	try {
+		if (runSignal?.aborted) throw abortReason(runSignal);
+		findings = snapshotExecutionFindings(await waitForOperation(analyst.analyze(value, analystContext), executionSignal, analystAbortGraceMs(analyst)), exact, `AnalystRegistry.runExact analyst "${analyst.id}" findings`);
+	} catch (error) {
+		const cause = error instanceof Error ? error : new Error(String(error));
+		analysisFailure = cause;
+		let hookFindings = [];
+		if (!executionSignal?.aborted) try {
+			hookFindings = snapshotExecutionFindings(await waitForHook(plan.hooks.onError ? () => plan.hooks.onError?.({
 				analyst,
-				ctx,
+				error: cause,
 				runId: plan.runId
-			}) : void 0, runSignal);
+			}) : void 0, executionSignal) ?? [], exact, `AnalystRegistry.runExact analyst "${analyst.id}" onError findings`);
 		} catch (error) {
-			if (!exact) throw error;
-			executionFailure = error;
-			break;
-		}
-		if (runSignal?.aborted) {
-			const summary = abortedBeforeStartSummary(analyst, runSignal, Date.now() - t0);
-			executions.push({
-				summary,
-				findings: [],
-				budgetDebitUsd: 0
-			});
-			yield snapshotExecutionEvent({
-				type: "analyst-skipped",
-				summary
-			}, exact);
-			if (exact) {
-				executionFailure = abortReason(runSignal);
-				break;
-			}
-			continue;
-		}
-		let effectiveBudget;
-		try {
-			effectiveBudget = validateEffectiveBudget(ctx.budgetUsd, budgetCeilingUsd, analyst.id);
-		} catch (error) {
-			if (!exact) throw error;
-			executionFailure = error;
-			break;
+			lifecycleFailure = error;
 		}
-		const analystContext = exact ? ctx : { ...ctx };
-		const executionSignal = exact ? ctx.signal : runSignal;
-		yield snapshotExecutionEvent({
-			type: "analyst-started",
+		findings = hookFindings;
+	}
+	return {
+		findings,
+		analysisFailure,
+		lifecycleFailure
+	};
+}
+/** The summary of one finished analyst, logged as ok or failed. */
+function summarizeAnalyst(st, analyst, analysis, usage, t0, effectiveBudget) {
+	const { plan, exact } = st;
+	const { findings, analysisFailure } = analysis;
+	if (analysisFailure === void 0) {
+		const summary = {
 			analyst_id: analyst.id,
-			started_at: new Date(t0).toISOString()
-		}, exact);
-		let findings;
-		let summary;
-		let lifecycleFailure;
-		let analysisFailure;
-		try {
-			if (runSignal?.aborted) throw abortReason(runSignal);
-			findings = snapshotExecutionFindings(await waitForOperation(analyst.analyze(input.value, analystContext), executionSignal, analystAbortGraceMs(analyst)), exact, `AnalystRegistry.runExact analyst "${analyst.id}" findings`);
-		} catch (error) {
-			const cause = error instanceof Error ? error : new Error(String(error));
-			analysisFailure = cause;
-			let hookFindings = [];
-			if (!executionSignal?.aborted) try {
-				hookFindings = snapshotExecutionFindings(await waitForHook(plan.hooks.onError ? () => plan.hooks.onError?.({
-					analyst,
-					error: cause,
-					runId: plan.runId
-				}) : void 0, executionSignal) ?? [], exact, `AnalystRegistry.runExact analyst "${analyst.id}" onError findings`);
-			} catch (error) {
-				lifecycleFailure = error;
-			}
-			findings = hookFindings;
-		}
-		let usage;
-		try {
-			usage = resolveUsage(analyst, usageReceipts, exact);
-		} catch (error) {
-			if (!exact) throw error;
-			executionFailure = error;
-			break;
-		}
-		if (analysisFailure === void 0) {
-			summary = {
-				analyst_id: analyst.id,
-				status: "ok",
-				findings_count: findings.length,
-				latency_ms: Date.now() - t0,
-				usage,
-				...exact ? { allocated_budget_usd: effectiveBudget ?? null } : {}
-			};
-			log(`[analyst] ok ${analyst.id}`, {
-				runId: plan.runId,
-				findings: findings.length,
-				latency_ms: summary.latency_ms,
-				cost_usd: knownCostUsd(usage),
-				cost_kind: usage.cost.kind,
-				input_tokens: usage.tokens?.input ?? null,
-				output_tokens: usage.tokens?.output ?? null
-			});
-		} else {
-			const errorClass = analysisFailure.constructor.name || "Error";
-			const errorMessage = exact && analysisFailure.message.length === 0 ? "Analyst failed without an error message" : analysisFailure.message;
-			summary = {
-				analyst_id: analyst.id,
-				status: "failed",
-				findings_count: findings.length,
-				latency_ms: Date.now() - t0,
-				usage,
-				...exact ? { allocated_budget_usd: effectiveBudget ?? null } : {},
-				error: {
-					class: errorClass,
-					message: errorMessage
-				}
-			};
-			log(`[analyst] FAIL ${analyst.id}`, {
-				runId: plan.runId,
-				error_class: errorClass,
-				error: errorMessage,
-				cost_usd: knownCostUsd(usage),
-				cost_kind: usage.cost.kind
-			});
-		}
-		logUncapturedBudgetWarning({
-			analyst,
-			runId: plan.runId,
-			budgetUsd: effectiveBudget,
+			status: "ok",
+			findings_count: findings.length,
+			latency_ms: Date.now() - t0,
 			usage,
-			log
-		});
-		const execution = {
-			summary,
-			findings,
-			budgetDebitUsd: budgetDebit(summary.usage, effectiveBudget)
+			...exact ? { allocated_budget_usd: effectiveBudget ?? null } : {}
 		};
-		if (exact) try {
-			executionCost([...executions, execution], true);
-		} catch (error) {
-			executionFailure = error;
-			break;
-		}
-		executions.push(execution);
-		if (plan.budget.kind === "dynamic" && remainingUsd !== void 0) remainingUsd = Math.max(0, remainingUsd - execution.budgetDebitUsd);
-		if (plan.chainFindings) upstreamFindings.push(...findings);
-		if (lifecycleFailure !== void 0) {
-			if (!exact) throw lifecycleFailure;
-			executionFailure = lifecycleFailure;
-			break;
-		}
-		const hookValues = snapshotAfterHookValues(summary, findings, exact);
-		try {
-			await waitForHook(plan.hooks.onAfterAnalyze ? () => plan.hooks.onAfterAnalyze?.({
-				analyst,
-				summary: hookValues.summary,
-				findings: hookValues.findings,
-				runId: plan.runId
-			}) : void 0, executionSignal);
-		} catch (error) {
-			if (!exact) throw error;
-			executionFailure = error;
-			break;
-		}
-		yield snapshotExecutionEvent({
-			type: "analyst-completed",
-			summary,
-			findings
-		}, exact);
-		if (exact && runSignal?.aborted) {
-			executionFailure = abortReason(runSignal);
-			break;
+		plan.log(`[analyst] ok ${analyst.id}`, {
+			runId: plan.runId,
+			findings: findings.length,
+			latency_ms: summary.latency_ms,
+			cost_usd: knownCostUsd(usage),
+			cost_kind: usage.cost.kind,
+			input_tokens: usage.tokens?.input ?? null,
+			output_tokens: usage.tokens?.output ?? null
+		});
+		return summary;
+	}
+	const errorClass = analysisFailure.constructor.name || "Error";
+	const errorMessage = exact && analysisFailure.message.length === 0 ? "Analyst failed without an error message" : analysisFailure.message;
+	const summary = {
+		analyst_id: analyst.id,
+		status: "failed",
+		findings_count: findings.length,
+		latency_ms: Date.now() - t0,
+		usage,
+		...exact ? { allocated_budget_usd: effectiveBudget ?? null } : {},
+		error: {
+			class: errorClass,
+			message: errorMessage
 		}
+	};
+	plan.log(`[analyst] FAIL ${analyst.id}`, {
+		runId: plan.runId,
+		error_class: errorClass,
+		error: errorMessage,
+		cost_usd: knownCostUsd(usage),
+		cost_kind: usage.cost.kind
+	});
+	return summary;
+}
+/** One analyst: allocate, run, summarize, and record it on the run. */
+async function* runAnalyst(st, analyst, input) {
+	const { plan, exact, runSignal } = st;
+	const t0 = Date.now();
+	if (runSignal?.aborted) return yield* skipAborted(st, analyst, runSignal);
+	if (input.kind === "missing") return yield* skipMissingInput(st, analyst);
+	const { ctx, usageReceipts, budgetCeilingUsd } = buildAnalystContext(st, analyst);
+	try {
+		await waitForHook(plan.hooks.onBeforeAnalyze ? () => plan.hooks.onBeforeAnalyze?.({
+			analyst,
+			ctx,
+			runId: plan.runId
+		}) : void 0, runSignal);
+	} catch (error) {
+		if (!exact) throw error;
+		st.executionFailure = error;
+		return "stop";
+	}
+	if (runSignal?.aborted) return yield* skipAborted(st, analyst, runSignal, Date.now() - t0);
+	let effectiveBudget;
+	try {
+		effectiveBudget = validateEffectiveBudget(ctx.budgetUsd, budgetCeilingUsd, analyst.id);
+	} catch (error) {
+		if (!exact) throw error;
+		st.executionFailure = error;
+		return "stop";
+	}
+	const analystContext = exact ? ctx : { ...ctx };
+	const executionSignal = exact ? ctx.signal : runSignal;
+	yield snapshotExecutionEvent({
+		type: "analyst-started",
+		analyst_id: analyst.id,
+		started_at: new Date(t0).toISOString()
+	}, exact);
+	const analysis = await analyzeOne(st, analyst, input.value, analystContext, executionSignal);
+	const { findings, lifecycleFailure } = analysis;
+	let usage;
+	try {
+		usage = resolveUsage(analyst, usageReceipts, exact);
+	} catch (error) {
+		if (!exact) throw error;
+		st.executionFailure = error;
+		return "stop";
 	}
+	const summary = summarizeAnalyst(st, analyst, analysis, usage, t0, effectiveBudget);
+	logUncapturedBudgetWarning({
+		analyst,
+		runId: plan.runId,
+		budgetUsd: effectiveBudget,
+		usage,
+		log: plan.log
+	});
+	const execution = {
+		summary,
+		findings,
+		budgetDebitUsd: budgetDebit(summary.usage, effectiveBudget)
+	};
+	if (exact) try {
+		executionCost([...st.executions, execution], true);
+	} catch (error) {
+		st.executionFailure = error;
+		return "stop";
+	}
+	st.executions.push(execution);
+	if (plan.budget.kind === "dynamic" && st.remainingUsd !== void 0) st.remainingUsd = Math.max(0, st.remainingUsd - execution.budgetDebitUsd);
+	if (plan.chainFindings) st.upstreamFindings.push(...findings);
+	if (lifecycleFailure !== void 0) {
+		if (!exact) throw lifecycleFailure;
+		st.executionFailure = lifecycleFailure;
+		return "stop";
+	}
+	const hookValues = snapshotAfterHookValues(summary, findings, exact);
+	try {
+		await waitForHook(plan.hooks.onAfterAnalyze ? () => plan.hooks.onAfterAnalyze?.({
+			analyst,
+			summary: hookValues.summary,
+			findings: hookValues.findings,
+			runId: plan.runId
+		}) : void 0, executionSignal);
+	} catch (error) {
+		if (!exact) throw error;
+		st.executionFailure = error;
+		return "stop";
+	}
+	yield snapshotExecutionEvent({
+		type: "analyst-completed",
+		summary,
+		findings
+	}, exact);
+	if (exact && runSignal?.aborted) {
+		st.executionFailure = abortReason(runSignal);
+		return "stop";
+	}
+	return "next";
+}
+/** Assemble the result, run the completion hook, and yield it. A failed exact run throws with its partial receipt. */
+async function* finishRun(st) {
+	const { plan, runSignal, executions } = st;
 	const summaries = executions.map(({ summary }) => summary);
 	const findings = executions.flatMap((execution) => execution.findings);
-	const cost = executionCost(executions, exact);
+	const cost = executionCost(executions, st.exact);
 	const baseResult = {
 		run_id: plan.runId,
-		correlation_id: correlationId,
-		started_at: startedAt,
+		correlation_id: st.correlationId,
+		started_at: st.startedAt,
 		ended_at: (/* @__PURE__ */ new Date()).toISOString(),
 		findings,
 		per_analyst: summaries,
@@ -2169,7 +2201,7 @@ async function* executePlanStream(plan) {
 		return;
 	}
 	let completeResult;
-	if (executionFailure === void 0) try {
+	if (st.executionFailure === void 0) try {
 		completeResult = snapshotExactAnalystRunReceipt({
 			...baseResult,
 			execution_plan: plan.executionSnapshot,
@@ -2177,17 +2209,17 @@ async function* executePlanStream(plan) {
 		}, "AnalystRegistry.runExact result");
 		await waitForHook(plan.hooks.onComplete ? () => plan.hooks.onComplete?.({ result: completeResult }) : void 0, runSignal);
 	} catch (error) {
-		executionFailure = error;
+		st.executionFailure = error;
 	}
-	if (runSignal?.aborted) executionFailure ??= abortReason(runSignal);
-	if (executionFailure === void 0 && completeResult) {
+	if (runSignal?.aborted) st.executionFailure ??= abortReason(runSignal);
+	if (st.executionFailure === void 0 && completeResult) {
 		yield snapshotExecutionEvent({
 			type: "run-completed",
 			result: completeResult
 		}, true);
 		return;
 	}
-	const cause = executionFailure instanceof Error ? executionFailure : new Error(String(executionFailure));
+	const cause = st.executionFailure instanceof Error ? st.executionFailure : new Error(String(st.executionFailure));
 	const errorClass = cause.constructor.name || "Error";
 	const errorMessage = cause.message.trim().length === 0 ? "Exact analyst run failed without a message" : cause.message;
 	throw new ExactAnalystRunExecutionError(`exact analyst run failed after starting: ${errorMessage}; partial result is attached`, {
@@ -2348,4 +2380,4 @@ function buildDefaultAnalystRegistry(options = {}) {
 //#endregion
 export { readAnalystReview as _, KNOWLEDGE_POISONING_KIND_SPEC as a, FAILURE_MODE_KIND_SPEC as c, emitControlIntegrityFindings as d, behavioralAnalyst as f, completedAnalystReviewQuality as g, assertUniqueFindingIds as h, DEFAULT_TRACE_ANALYST_KINDS as i, CONTROL_INTEGRITY_ANALYST as l, analystRunDigest as m, AnalystRegistry as n, KNOWLEDGE_GAP_KIND_SPEC as o, analystFindingDigest as p, ExactAnalystRunExecutionError as r, IMPROVEMENT_KIND_SPEC as s, buildDefaultAnalystRegistry as t, ControlIntegrityAnalyst as u, snapshotAnalystRun as v, validateAnalystReviewDecisions as y };
 
-//# sourceMappingURL=default-registry-ClYjq3QE.js.map
+//# sourceMappingURL=default-registry-BrKmT01n.js.map