@tangle-network/agent-runtime 0.261.0 → 0.262.0

package/dist/{coordination-driver-LmDxHvAO.js → coordination-driver-COGC8FK2.js}

@@ -1,4 +1,4 @@
-import { At as workerTraceAnalysisStore, Bi as chargedTokens, Ci as detachedFrozen, Gi as promptCacheTokenClasses, Mt as assertValidBudget, Qt as createPeerMailbox, S as meterRuntimeOwnedProviderAttempt, W as resolveSpawnResourcePaths, Zi as unmeteredSpend, Zn as resolveRedactor, _t as FileResultBlobStore, a as pickBestDelivered, bt as InMemorySpawnJournal, di as providerAttemptEvidence, dt as createExecutorRegistry, ea as addResourceSpend, ei as prepareJsonlAppend, g as withDriverExecutor, kt as parseWorkerToolTraceArtifact, na as withBudgetResources, ni as writeAllBytes, nn as isLiveNodeStatus, o as runFinalizer, qt as createInbox, r as bestDelivered, rn as isTerminalNodeStatus, rt as freeSlots, s as runTree, ti as readCommittedJsonLines, tt as errMessage, vt as FileSpawnJournal, wn as runBrainLoop, yt as InMemoryResultBlobStore, z as scopeRetainedOwnerResourceReader } from "./supervisor-yavsoQQo.js";
+import { Ct as InMemorySpawnJournal, Dn as runBrainLoop, Ei as detachedFrozen, Ft as assertValidBudget, H as scopeRetainedOwnerResourceReader, Ji as promptCacheTokenClasses, Mt as parseWorkerToolTraceArtifact, Nt as workerTraceAnalysisStore, St as InMemoryResultBlobStore, Ui as chargedTokens, Xt as createInbox, a as pickBestDelivered, aa as withBudgetResources, ai as writeAllBytes, an as isLiveNodeStatus, bt as FileResultBlobStore, ea as unmeteredSpend, er as resolveRedactor, ii as readCommittedJsonLines, it as errMessage, mi as providerAttemptEvidence, mt as createExecutorRegistry, o as runFinalizer, on as isTerminalNodeStatus, ot as freeSlots, q as resolveSpawnResourcePaths, r as bestDelivered, ra as addResourceSpend, ri as prepareJsonlAppend, s as runTree, tn as createPeerMailbox, v as withDriverExecutor, w as meterRuntimeOwnedProviderAttempt, xt as FileSpawnJournal } from "./supervisor-BGGvnXvV.js";
 import { f as RuntimeRunStateError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { A as writeWorkerCancellation, M as writeWorkerSteerAcknowledgement, b as workerCancellationsDir, c as readWorkerCancelRequests, d as readWorkerSteerRequests, k as writeRunCancellation, l as readWorkerCancellation, o as readRunCancelRequest, r as claimWorkerSteerDelivery, s as readRunCancellation, u as readWorkerSteerAcknowledgement } from "./run-layout-vwd4SwX_.js";
 import { agentProfileSchema, canonicalCandidateDigest } from "@tangle-network/agent-interface";
@@ -74,6 +74,12 @@ function createEventBus(now = Date.now) {
 		}
 		return best;
 	};
+	const pullRecord = (kinds) => {
+		const i = bestIndex(kinds);
+		if (i < 0) return void 0;
+		pulled++;
+		return queue.splice(i, 1)[0];
+	};
 	return {
 		async publish(event, opts) {
 			const record = staged.get(event) ?? {
@@ -92,10 +98,11 @@ function createEventBus(now = Date.now) {
 			return record;
 		},
 		pull(kinds) {
-			const i = bestIndex(kinds);
-			if (i < 0) return void 0;
-			pulled++;
-			return queue.splice(i, 1)[0]?.event;
+			return pullRecord(kinds)?.event;
+		},
+		pullRecord,
+		queued(kinds) {
+			return queue.filter((r) => matches(r, kinds));
 		},
 		subscribe(handler) {
 			subscribers.push(handler);
@@ -498,7 +505,8 @@ const journalEventKinds = [
 	"delivery-attempt",
 	"mail",
 	"escalation",
-	"analyst-defined"
+	"analyst-defined",
+	"acknowledgement"
 ];
 /** The reserved coordination verb names — the complete set `createCoordinationTools` can emit
 *  (the analyst pair is conditional but still reserved). A driver's extra WORK tools must not
@@ -522,6 +530,7 @@ const coordinationVerbNames = [
 	"ask_parent",
 	"submit_result",
 	"stop",
+	"report_blocked",
 	"read_journal",
 	"list_analysts",
 	"run_analyst",
@@ -798,6 +807,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 	let stopNotified = false;
 	let submitted = priorSubmission === void 0 ? void 0 : detachedFrozen({ result: priorSubmission.event.result });
 	let submissionInFlight;
+	let blockedEvidence;
 	let questionSeq = 0;
 	const ledger = [];
 	const questions = [...opts.priorQuestions ?? []];
@@ -884,6 +894,27 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		});
 		return readyInFlight;
 	};
+	const deliveries = [];
+	let driverAttempt;
+	let journalReadTo = 0;
+	let lastRejection;
+	const flushedAnalystRuns = /* @__PURE__ */ new Set();
+	const eventWorker = (event) => event.type === "settled" ? event.worker.id : event.type === "finding" ? event.finding.fromWorker : event.type === "question" ? event.question.from : void 0;
+	const acknowledge = async (targets, by) => {
+		const fresh = targets.filter((delivery) => !delivery.acknowledged);
+		if (fresh.length === 0) return [];
+		const seqs = fresh.map((delivery) => delivery.record.seq);
+		await bus.publish({
+			type: "acknowledgement",
+			acknowledgement: detachedFrozen({
+				seqs,
+				by,
+				...driverAttempt === void 0 ? {} : { attempt: driverAttempt }
+			})
+		}, { queue: false });
+		for (const delivery of fresh) delivery.acknowledged = true;
+		return seqs;
+	};
 	const urgencyPriority = (u) => u === "blocks-run" ? 20 : u === "blocks-step" ? 10 : 0;
 	const str = (v, field) => {
 		if (typeof v !== "string" || v.length === 0) throw new Error(`coordination tools: "${field}" must be a non-empty string`);
@@ -1146,6 +1177,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		await bus.publish(pending.event);
 		if (pending.analystRun) {
 			analystRuns.delete(pending.worker.id);
+			flushedAnalystRuns.add(pending.worker.id);
 			unwatchWorker(pending.worker.id);
 			pendingSettlement = void 0;
 			const { route } = pending.analystRun;
@@ -1397,6 +1429,10 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			type: "analyst-defined",
 			...ev.analyst
 		};
+		if (ev.type === "acknowledgement") return {
+			type: "acknowledgement",
+			...ev.acknowledgement
+		};
 		return {
 			type: ev.type,
 			...ev.down
@@ -1607,9 +1643,11 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			usedBytes += bytes;
 		}
 		const last = entries[entries.length - 1];
+		const nextRow = last === void 0 ? sinceRow : last.row + 1;
+		journalReadTo = Math.max(journalReadTo, nextRow);
 		return {
 			entries,
-			nextRow: last === void 0 ? sinceRow : last.row + 1,
+			nextRow,
 			remaining: matching.length - index,
 			truncated: bounded,
 			bounds: {
@@ -1701,6 +1739,39 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		...resumed ? { resumed: true } : {}
 	});
 	const liveSnapshot = () => opts.scope.view.nodes.filter((n) => isLiveNodeStatus(n.status)).map((n) => projectNodeEvidence(n));
+	const openWork = () => {
+		const received = new Set(ledger.map((worker) => worker.id));
+		const nodes = opts.scope.view?.nodes ?? [];
+		return {
+			running: nodes.filter((node) => isLiveNodeStatus(node.status) && node.status !== "waiting"),
+			unqueued: nodes.filter((node) => !isLiveNodeStatus(node.status) && !received.has(node.id) && !flushedAnalystRuns.has(node.id)),
+			queued: bus.queued(["settled", "finding"])
+		};
+	};
+	const openWorkRefusal = (verb) => {
+		const { running, unqueued, queued } = openWork();
+		if (running.length === 0 && unqueued.length === 0 && queued.length === 0) return void 0;
+		const parts = [];
+		if (running.length > 0) parts.push(`${running.length} worker${running.length === 1 ? " is" : "s are"} still running (${running.map((node) => node.id).join(", ")})`);
+		const waiting = unqueued.length + queued.length;
+		if (waiting > 0) parts.push(`${waiting} event${waiting === 1 ? " is" : "s are"} waiting for you in await_event`);
+		return {
+			error: "open-work",
+			reason: `${parts.join(" and ")}. Call await_event until it returns idle, read each settled worker's output, and then call ${verb} again. Nothing was ${verb === "stop" ? "stopped" : "checked"}.`,
+			running: running.map((node) => ({
+				id: node.id,
+				label: node.label,
+				status: node.status
+			})),
+			waiting: [...queued.map((record) => ({
+				type: record.event.type,
+				...eventWorker(record.event) === void 0 ? {} : { worker: eventWorker(record.event) }
+			})), ...unqueued.map((node) => ({
+				type: "settled",
+				worker: node.id
+			}))]
+		};
+	};
 	const freeWorkerSlots = () => usesTreeWideLimit() ? sharedWorkerCapacity()?.freeSlots ?? null : freeSlots(localLiveWorkerCount(), maxLiveWorkers);
 	const readProgress = (id) => {
 		const scope = opts.scope;
@@ -2110,24 +2181,50 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		},
 		{
 			name: "await_event",
-			description: "Wait for and pull the next message a worker, sub-driver, or analyst sent up — the unified inbox. Read a settled artifact with the returned `outputRead` call; the receipt carries its reference, not its bytes. An event is one of: a settled worker output ('settled'), a question needing your answer ('question', from ask_parent / the worker's ask-user), or a trace-analyst finding ('finding', from analyze-on-settle). Pass kinds:['settled'] for just the next finished worker; omit `kinds` to also receive questions and findings. Returns { idle: true } when nothing is queued and no workers are live. If a worker is still running when the wait elapses, returns { pending: true, live: [...] } (the workers still in flight) instead of blocking indefinitely — call await_event again to keep waiting; the settlement is not lost. Every reply carries `freeSlots`: how many more workers you can start right now (`null` = uncapped). A settled worker frees its slot, so `freeSlots > 0` means capacity is sitting idle — spawn into it before waiting again.",
+			description: "Wait for and pull the next message a worker, sub-driver, or analyst sent up — the unified inbox. Read a settled artifact with the returned `outputRead` call; the receipt carries its reference, not its bytes. An event is one of: a settled worker output ('settled'), a question needing your answer ('question', from ask_parent / the worker's ask-user), or a trace-analyst finding ('finding', from analyze-on-settle). Pass kinds:['settled'] for just the next finished worker; omit `kinds` to also receive questions and findings. Returns { idle: true } when nothing is queued and no workers are live. If a worker is still running when the wait elapses, returns { pending: true, live: [...] } (the workers still in flight) instead of blocking indefinitely — call await_event again to keep waiting; the settlement is not lost. Every reply carries `freeSlots`: how many more workers you can start right now (`null` = uncapped). A settled worker frees its slot, so `freeSlots > 0` means capacity is sitting idle — spawn into it before waiting again. Each event carries `eventSeq`; pass the ones you have processed in `acknowledge` on a later call. An event delivered to a turn that ends in failure is named again when you are re-entered, until it is acknowledged.",
 			inputSchema: {
 				type: "object",
-				properties: { kinds: {
-					type: "array",
-					items: {
-						type: "string",
-						enum: [...awaitableEventKinds]
+				properties: {
+					kinds: {
+						type: "array",
+						items: {
+							type: "string",
+							enum: [...awaitableEventKinds]
+						},
+						description: "Restrict to these event kinds (any if omitted)."
 					},
-					description: "Restrict to these event kinds (any if omitted)."
-				} }
+					acknowledge: {
+						type: "array",
+						items: {
+							type: "integer",
+							minimum: 0
+						},
+						description: "The eventSeq of each earlier event you have now processed."
+					}
+				}
 			},
 			handler: async (raw) => {
-				const k = obj(raw).kinds;
+				const args = raw === void 0 ? {} : obj(raw);
+				const k = args.kinds;
 				const kinds = Array.isArray(k) ? k.filter(isAwaitableEventKind) : void 0;
-				let ev = bus.pull(kinds);
+				if (Array.isArray(args.acknowledge)) {
+					const named = new Set(args.acknowledge.filter((value) => typeof value === "number" && Number.isInteger(value)));
+					await acknowledge(deliveries.filter((delivery) => named.has(delivery.record.seq)), "manager");
+				}
+				const deliver = (record) => {
+					deliveries.push({
+						record,
+						attempt: driverAttempt,
+						acknowledged: false
+					});
+					return {
+						...projectEvent(record.event),
+						eventSeq: record.seq
+					};
+				};
+				let ev = bus.pullRecord(kinds);
 				if (ev) return {
-					...projectEvent(ev),
+					...deliver(ev),
 					freeSlots: freeWorkerSlots()
 				};
 				const raced = await raceDrainWithTimeout(ensureDrain());
@@ -2136,13 +2233,13 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					live: liveSnapshot(),
 					freeSlots: freeWorkerSlots()
 				};
-				ev = bus.pull(kinds);
+				ev = bus.pullRecord(kinds);
 				if (!ev) return {
 					idle: !raced.drained,
 					freeSlots: freeWorkerSlots()
 				};
 				return {
-					...projectEvent(ev),
+					...deliver(ev),
 					freeSlots: freeWorkerSlots()
 				};
 			}
@@ -2318,6 +2415,18 @@ function createCoordinationToolsForManager(opts, lifetime) {
 				};
 				const a = obj(raw);
 				if (!Object.hasOwn(a, "result")) throw new Error("submit_result: \"result\" is required");
+				const open = openWorkRefusal("submit_result");
+				if (open !== void 0) {
+					lastRejection = {
+						at: Date.now(),
+						reason: String(open.reason)
+					};
+					return {
+						accepted: false,
+						stop: false,
+						...open
+					};
+				}
 				const result = structuredClone(a.result);
 				let accepted = false;
 				let thrown;
@@ -2336,10 +2445,15 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					} catch (error) {
 						diagnosticError = error instanceof Error ? error.message : String(error);
 					}
+					const refusal = thrown === void 0 ? `the independent check did not pass on this result${explanation ? `. ${explanation}` : deliverable.describe ? `. Expected: ${deliverable.describe}` : ""}` : `the independent check THREW, so nothing was accepted: ${thrown}. This is a fault in the check, not necessarily in your result — report it rather than resubmitting unchanged`;
+					lastRejection = {
+						at: Date.now(),
+						reason: refusal
+					};
 					return {
 						accepted: false,
 						stop: false,
-						reason: thrown === void 0 ? `the independent check did not pass on this result${explanation ? `. ${explanation}` : deliverable.describe ? `. Expected: ${deliverable.describe}` : ""}` : `the independent check THREW, so nothing was accepted: ${thrown}. This is a fault in the check, not necessarily in your result — report it rather than resubmitting unchanged`,
+						reason: refusal,
 						...diagnosticError === void 0 ? {} : { diagnosticError }
 					};
 				}
@@ -2372,6 +2486,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 				} finally {
 					if (submissionInFlight === commit) submissionInFlight = void 0;
 				}
+				await acknowledge(deliveries, "result-accepted");
 				return {
 					accepted: true,
 					retained: "this-result",
@@ -2401,6 +2516,11 @@ function createCoordinationToolsForManager(opts, lifetime) {
 						...unheard.length > 0 ? { unheardQuestionIds: unheard.map((q) => q.id) } : {}
 					});
 				}
+				const open = openWorkRefusal("stop");
+				if (open !== void 0) return Promise.resolve({
+					stopped: false,
+					...open
+				});
 				stopped = true;
 				const r = obj(raw).reason;
 				reason = typeof r === "string" ? r : void 0;
@@ -2408,6 +2528,97 @@ function createCoordinationToolsForManager(opts, lifetime) {
 				return Promise.resolve({ stopped: true });
 			}
 		},
+		{
+			name: "report_blocked",
+			description: [
+				"Report that a tool you need keeps failing, so the run cannot go on.",
+				"Name the tool, the arguments you called it with, and the error you saw.",
+				"The coordinator calls that tool again, with those arguments, under your identity.",
+				"When the call succeeds you are not blocked: the reply carries its result, and you continue.",
+				"When it fails again, the run ends as blocked and the record keeps both errors.",
+				"submit_result, stop and report_blocked cannot be probed."
+			].join(" "),
+			inputSchema: {
+				type: "object",
+				properties: {
+					tool: {
+						type: "string",
+						description: "The tool that failed, as you called it."
+					},
+					arguments: {
+						type: "object",
+						description: "The arguments you called it with. Omit for none."
+					},
+					error: {
+						type: "string",
+						description: "The error the tool returned to you."
+					}
+				},
+				required: ["tool", "error"],
+				additionalProperties: false
+			},
+			handler: async (raw) => {
+				const a = obj(raw);
+				const named = str(a.tool, "tool");
+				const reported = str(a.error, "error");
+				const bare = named.replace(/^mcp__.+?__/u, "").replace(/^.*?coordination_+/u, "");
+				if (unprobeableVerbs.has(bare)) return {
+					blocked: false,
+					error: "unprobeable",
+					reason: `${bare} changes the run, so the coordinator does not call it for you`
+				};
+				const target = opts.resolveProbeTool?.(bare) ?? tools.find((tool) => tool.name === bare);
+				if (target === void 0) return {
+					blocked: false,
+					error: "unknown-tool",
+					reason: `no tool named ${JSON.stringify(bare)} is served to you, so there is nothing to probe; call the tools you were given`
+				};
+				const args = a.arguments === void 0 ? {} : typeof a.arguments === "object" && a.arguments !== null && !Array.isArray(a.arguments) ? a.arguments : void 0;
+				if (args === void 0) return {
+					blocked: false,
+					error: "invalid-arguments",
+					reason: "\"arguments\" must be an object"
+				};
+				let probe;
+				try {
+					probe = {
+						ok: true,
+						result: await runWithin(target.handler(structuredClone(args)), REPORT_BLOCKED_PROBE_MS, `the probe of ${bare} did not answer within ${REPORT_BLOCKED_PROBE_MS}ms`)
+					};
+				} catch (error) {
+					probe = {
+						ok: false,
+						error: error instanceof Error ? error.message : String(error)
+					};
+				}
+				if (probe.ok) return {
+					blocked: false,
+					probe: {
+						tool: bare,
+						ok: true,
+						result: probe.result
+					},
+					guidance: "The call worked when the coordinator made it under your identity, so the tool is not blocked. Use this result and continue the objective."
+				};
+				blockedEvidence = Object.freeze({
+					tool: bare,
+					reported,
+					probed: probe.error
+				});
+				stopped = true;
+				reason = `blocked: ${bare} failed when the coordinator probed it: ${probe.error}`;
+				notifyStop();
+				return {
+					blocked: true,
+					stopped: true,
+					probe: {
+						tool: bare,
+						ok: false,
+						error: probe.error
+					}
+				};
+			}
+		},
 		{
 			name: "read_journal",
 			description: [
@@ -2628,9 +2839,74 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		definedAnalysts: () => definedAnalysts,
 		drainResolved,
 		abortWorker,
+		beginDriverAttempt: (attempt) => {
+			driverAttempt = attempt;
+		},
+		endDriverAttempt: async (outcome) => {
+			const attempt = driverAttempt;
+			if (outcome === "completed") await acknowledge(deliveries.filter((delivery) => delivery.attempt === attempt), "turn-completed");
+		},
+		reentryState: () => {
+			const { unqueued, queued } = openWork();
+			const deliveredSettled = new Set(deliveries.flatMap((delivery) => delivery.record.event.type === "settled" ? [delivery.record.event.worker.id] : []));
+			return detachedFrozen({
+				journalRows: priorJournal.length + bus.history().length,
+				journalReadTo,
+				live: (opts.scope.view?.nodes ?? []).filter((node) => isLiveNodeStatus(node.status)).map((node) => ({
+					id: node.id,
+					label: node.label,
+					status: node.status
+				})),
+				settled: [...ledger.map((worker) => ({
+					id: worker.id,
+					status: worker.status,
+					...worker.status === "done" && worker.valid !== void 0 ? { valid: worker.valid } : {},
+					delivered: deliveredSettled.has(worker.id)
+				})), ...unqueued.map((node) => ({
+					id: node.id,
+					status: node.status === "done" ? "done" : "down",
+					delivered: false
+				}))],
+				waiting: [...queued.map((record) => ({
+					type: record.event.type,
+					...eventWorker(record.event) === void 0 ? {} : { worker: eventWorker(record.event) }
+				})), ...unqueued.map((node) => ({
+					type: "settled",
+					worker: node.id
+				}))],
+				unacknowledged: deliveries.filter((delivery) => !delivery.acknowledged).map((delivery) => ({
+					seq: delivery.record.seq,
+					type: delivery.record.event.type,
+					...eventWorker(delivery.record.event) === void 0 ? {} : { worker: eventWorker(delivery.record.event) },
+					...delivery.attempt === void 0 ? {} : { attempt: delivery.attempt }
+				})),
+				...lastRejection === void 0 ? {} : { lastRejection }
+			});
+		},
+		blocked: () => blockedEvidence,
 		...peerMail ? { peerMail } : {}
 	};
 }
+/** The verbs `report_blocked` never calls on a manager's behalf: each one changes the run. */
+const unprobeableVerbs = /* @__PURE__ */ new Set([
+	"submit_result",
+	"stop",
+	"report_blocked"
+]);
+/** How long one `report_blocked` probe may run before it counts as a failure. */
+const REPORT_BLOCKED_PROBE_MS = 6e4;
+async function runWithin(work, ms, message) {
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(new Error(message)), ms);
+		if (typeof timer?.unref === "function") timer.unref();
+	});
+	try {
+		return await Promise.race([work, timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
 function nextUnkeyedAssignmentOrdinal(scope) {
 	let next = 0;
 	const views = [scope.resume?.view, scope.view];
@@ -3745,6 +4021,7 @@ function driverAgent(opts) {
 		},
 		async act(task, scope) {
 			const ownerReader = opts.spawnResourceReader ?? (opts.spawnResourceRoot === void 0 ? scopeRetainedOwnerResourceReader(scope) : void 0);
+			let probeableByName;
 			const coord = createCoordinationTools({
 				scope,
 				blobs: opts.blobs,
@@ -3771,7 +4048,8 @@ function driverAgent(opts) {
 				...opts.priorCoordination?.questions.length ? { priorQuestions: opts.priorCoordination.questions } : {},
 				...opts.priorCoordination?.escalations?.length ? { priorEscalations: opts.priorCoordination.escalations } : {},
 				...opts.priorCoordination?.records.length ? { priorJournal: opts.priorCoordination.records } : {},
-				...opts.priorCoordination?.analystDefinitions?.length ? { priorAnalystDefinitions: opts.priorCoordination.analystDefinitions } : {}
+				...opts.priorCoordination?.analystDefinitions?.length ? { priorAnalystDefinitions: opts.priorCoordination.analystDefinitions } : {},
+				resolveProbeTool: (name) => probeableByName?.get(name)
 			});
 			await coord.ready();
 			const availableTools = [...coord.tools, ...opts.nodeTools ?? []];
@@ -3791,6 +4069,7 @@ function driverAgent(opts) {
 				};
 			});
 			const modelTools = selectedTools.flatMap((selected) => selected.kind === "descriptor" ? [selected.descriptor] : []);
+			probeableByName = new Map(modelTools.map((tool) => [tool.name, tool]));
 			const selectedExtraNames = new Set(selectedTools.flatMap((selected) => selected.kind === "extra" ? [selected.extra.name] : []));
 			opts.onCoordinationTools?.(modelTools);
 			const acknowledger = opts.controlDir === void 0 ? void 0 : createCancelAcknowledger({
@@ -4102,4 +4381,4 @@ function safeJson(v) {
 //#endregion
 export { downMessageRefusalReasons as A, ANALYST_DEFINITION_BOUNDS as C, coordinationVerbNames as D, canonicalFindingEvent as E, defaultToolDetectors as F, watchTrace as I, parseAuthoredAnalystDefinition as M, questionEscalationTargets as N, createCoordinationTools as O, createEventBus as P, watchRunCancellation as S, analystToolGroupNames as T, renderAnytimeTable as _, allOf as a, FileCoordinationLog as b, createProgressTracker as c, progressStop as d, sampleFromSettled as f, plateauLength as g, bestSoFar as h, finalizeBestDelivered as i, normalizeAnalyzeOnSettle as j, createCoordinationToolsForManager as k, noProgressFor as l, areaUnderCurve as m, createSteerAcknowledger as n, allWorkersStalled as o, anytimeReport as p, driverAgent as r, anyOf as s, createCancelAcknowledger as t, plateau as u, createFileRunContext as v, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as w, applyRunCancellation as x, createInMemoryRunContext as y };
 
-//# sourceMappingURL=coordination-driver-LmDxHvAO.js.map
+//# sourceMappingURL=coordination-driver-COGC8FK2.js.map