@tangle-network/agent-runtime 0.327.0 → 0.329.0

package/dist/{coordination-driver-Cd0KpYoT.js → coordination-driver-DsxFmzhm.js}

@@ -1,4 +1,4 @@
-import { $i as InMemoryResultBlobStore, Bt as createRouterTranscript, Ct as checkVerdictOf, Dt as failedItems, En as runBrainLoop, Ft as createExecutorRegistry, J as scopeRetainedOwnerResourceReader, Qi as FileSpawnJournal, T as meterRuntimeOwnedProviderAttempt, Ta as resolveRedactor, Zi as FileResultBlobStore, Zt as createInbox, _a as assertValidBudget, at as runtimeGraphMetadataKey, c as runTree, ca as parseWorkerToolTraceArtifact, da as detachedFrozen, ea as InMemorySpawnJournal, i as bestDelivered, ji as settlementFailureCause, la as workerTraceAnalysisStore, ma as errMessage, mi as providerAttemptEvidence, nn as createPeerMailbox, o as pickBestDelivered, on as isLiveNodeStatus, s as runFinalizer, sn as isTerminalNodeStatus, tt as resolveSpawnResourcePaths, ua as contentAddress, v as withDriverExecutor, w as meterRuntimeOwnedAccounting, yt as CheckUnavailableError } from "./supervisor-hIpqcCJr.js";
+import { $i as FileSpawnJournal, Dn as runBrainLoop, Ea as resolveRedactor, It as createExecutorRegistry, Mi as settlementFailureCause, Ot as failedItems, Qi as FileResultBlobStore, Qt as createInbox, T as meterRuntimeOwnedProviderAttempt, Vt as createRouterTranscript, Y as scopeRetainedOwnerResourceReader, bt as CheckUnavailableError, c as runTree, cn as isTerminalNodeStatus, da as contentAddress, ea as InMemoryResultBlobStore, fa as detachedFrozen, ha as errMessage, hi as providerAttemptEvidence, i as bestDelivered, la as parseWorkerToolTraceArtifact, nt as resolveSpawnResourcePaths, o as pickBestDelivered, ot as runtimeGraphMetadataKey, rn as createPeerMailbox, s as runFinalizer, sn as isLiveNodeStatus, ta as InMemorySpawnJournal, ua as workerTraceAnalysisStore, v as withDriverExecutor, va as assertValidBudget, w as meterRuntimeOwnedAccounting, wt as checkVerdictOf } from "./supervisor-U76PdEPD.js";
 import { f as RuntimeRunStateError, m as ValidationError } from "./errors-DodWX-cb.js";
 import { G as chargedTokens, gt as withBudgetResources, lt as unmeteredSpend, pt as addResourceSpend, tt as promptCacheTokenClasses } from "./sandbox-profile-compat-CVgQWb7T.js";
 import { a as readCommittedJsonLines, t as appendCommittedJsonLine } from "./jsonl-file-DBv31uPi.js";
@@ -253,6 +253,16 @@ function createWorkerOutputReader(blobs) {
 *
 * @experimental
 */
+/**
+* The substitution and the sentence a manager reads beside it. A manager that reports which model
+* did the work must read `modelSubstitution.ran`, never the model it asked for.
+*/
+function modelSubstitutionReport(substitution) {
+	return {
+		modelSubstitution: substitution,
+		modelWarning: `spawn authorization ran this worker on ${substitution.ran}, not the ${substitution.requested} you authored; attribute its work to ${substitution.ran}`
+	};
+}
 /** Where a question this driver cannot answer goes next. `answer_question` accepts these and
 *  nothing else, so the decision type states them and nothing else. */
 const questionEscalationTargets = ["parent", "user"];
@@ -521,7 +531,8 @@ const journalEventKinds = [
 	"analyst-assignment",
 	"acknowledgement",
 	"tool-outcome",
-	"lead-message"
+	"lead-message",
+	"map"
 ];
 /** 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
@@ -564,7 +575,8 @@ const wakeEventKinds = [
 	"settled",
 	"finding",
 	"tool-outcome",
-	"lead-message"
+	"lead-message",
+	"map"
 ];
 const idArg = {
 	type: "string",
@@ -884,6 +896,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		const node = nodeForWorker(settled.handle.id);
 		const assignmentId = settled.handle.assignmentId ?? node?.assignmentId;
 		const identity = settled.handle.identity ?? node?.identity;
+		const modelSubstitution = settled.handle.modelSubstitution ?? node?.modelSubstitution;
 		const materialization = settled.handle.materialization ?? node?.materialization;
 		const executionBindings = settled.handle.executionBindings ?? node?.executionBindings;
 		const settledAt = settled.settledAt ?? node?.settledAt;
@@ -895,6 +908,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			id: settled.handle.id,
 			...assignmentId === void 0 ? {} : { assignmentId },
 			...identity === void 0 ? {} : { identity },
+			...modelSubstitution === void 0 ? {} : modelSubstitutionReport(modelSubstitution),
 			...materialization === void 0 ? {} : { materialization },
 			...executionBindings === void 0 ? {} : { executionBindings },
 			...settledAt === void 0 ? {} : { settledAt },
@@ -1023,7 +1037,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		checkReads.push(entry);
 		return entry;
 	};
-	const eventWorker = (event) => event.type === "settled" ? event.worker.id : event.type === "finding" ? event.finding.fromWorker : event.type === "question" ? event.question.from : void 0;
+	const eventWorker = (event) => event.type === "settled" ? event.worker.id : event.type === "finding" ? event.finding.fromWorker : event.type === "question" ? event.question.from : event.type === "map" ? event.map.sourceWorker : void 0;
 	const acknowledge = async (targets, by) => {
 		const fresh = targets.filter((delivery) => !delivery.acknowledged);
 		if (fresh.length === 0) return [];
@@ -1343,6 +1357,271 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		analyst: kind,
 		sourceWorker
 	}, { alreadySpent: true }) });
+	const mapRoutes = opts.mapOnSettle ?? [];
+	const mapMembers = /* @__PURE__ */ new Map();
+	const textBytes = (value) => Buffer.byteLength(safeJsonText(value), "utf8");
+	const publishMap = async (event, wake = false) => {
+		const record = detachedFrozen({
+			type: "map",
+			map: event
+		});
+		if (wake) await bus.publish(record);
+		else await bus.publish(record, { queue: false });
+	};
+	const workerSlotBound = () => {
+		const capacity = opts.scope.workerCapacity;
+		if (capacity === void 0 || capacity.freeSlots === null) return void 0;
+		return capacity.working + capacity.freeSlots;
+	};
+	const mapSettlement = (settled, worker) => {
+		if (settled.kind !== "done" || worker.status !== "done") return {
+			outcome: "failed",
+			reason: worker.status === "down" ? worker.reason : "down"
+		};
+		if (worker.valid === false) return {
+			outcome: "failed",
+			reason: "its deliverable check rejected the result"
+		};
+		if (settled.out === void 0) return {
+			outcome: "empty",
+			reason: "it settled with no result"
+		};
+		return {
+			outcome: "delivered",
+			result: settled.out
+		};
+	};
+	const startMapSpawn = async (expansion, role, profile, task, index) => {
+		const { route } = expansion;
+		const name = typeof profile.name === "string" && profile.name.length > 0 ? profile.name : "worker";
+		let response;
+		try {
+			response = await admitSpawn({
+				profile,
+				args: {
+					label: index === void 0 ? name : `${name}#${index}`,
+					...role === "item" && route.itemBudget !== void 0 ? { budget: route.itemBudget } : {}
+				},
+				task,
+				key: void 0,
+				continuity: { continuity: "fresh" },
+				successorOf: void 0,
+				preflightProfile: () => opts.resolveSpawnProfile ? detachedFrozen(opts.resolveSpawnProfile(profile)) : profile,
+				resourcesFromPath: [],
+				defaultLabel: name,
+				map: Object.freeze({
+					edge: route.edge,
+					role,
+					...index === void 0 ? {} : { index }
+				})
+			});
+		} catch (error) {
+			return { refused: errMessage(error) };
+		}
+		const started = response;
+		if (typeof started.workerId === "string") {
+			mapMembers.set(started.workerId, {
+				expansion,
+				role,
+				...index === void 0 ? {} : { index },
+				bytes: textBytes(task)
+			});
+			return { workerId: started.workerId };
+		}
+		return { refused: typeof started.reason === "string" ? started.reason : "spawn refused" };
+	};
+	const mapItemProfile = async (route) => {
+		if ("profile" in route.item) return { profile: route.item.profile };
+		if (!opts.graphs) return { refused: "a graph item starts through run_graph, which this manager does not serve" };
+		const prepared = await opts.graphs.prepare({ graph: route.item.graph });
+		return prepared.ok ? { profile: detachedFrozen(prepared.profile) } : { refused: prepared.reason };
+	};
+	const startMapItem = async (expansion, index) => {
+		const { route } = expansion;
+		const resolved = await mapItemProfile(route);
+		const started = "refused" in resolved ? resolved : await startMapSpawn(expansion, "item", resolved.profile, expansion.items[index], index);
+		if ("workerId" in started) {
+			expansion.inFlight += 1;
+			return;
+		}
+		const reason = `item spawn refused: ${started.refused}`;
+		expansion.settlements[index] = {
+			outcome: "unpropagated",
+			reason
+		};
+		if (route.onItemFailure === "all-or-refuse") expansion.stopped = true;
+		await publishMap({
+			edge: route.edge,
+			phase: "item",
+			outcome: "unpropagated",
+			sourceWorker: expansion.sourceWorker,
+			index,
+			bytes: 0,
+			reason
+		});
+	};
+	const pumpMap = async (expansion) => {
+		const { route, items } = expansion;
+		while (!expansion.stopped && expansion.inFlight < route.concurrency && expansion.next < items.length) {
+			const index = expansion.next;
+			expansion.next += 1;
+			await startMapItem(expansion, index);
+		}
+		if (expansion.inFlight === 0) await finishMap(expansion);
+	};
+	const finishMap = async (expansion, closed) => {
+		if (expansion.finished) return;
+		expansion.finished = true;
+		const { route, items, sourceWorker } = expansion;
+		for (let index = expansion.next; index < items.length; index += 1) {
+			const reason = closed ?? "not started: all-or-refuse stopped this map after an item failed";
+			expansion.settlements[index] = {
+				outcome: "unpropagated",
+				reason
+			};
+			await publishMap({
+				edge: route.edge,
+				phase: "item",
+				outcome: "unpropagated",
+				sourceWorker,
+				index,
+				bytes: 0,
+				reason
+			});
+		}
+		expansion.next = items.length;
+		const results = [];
+		const failures = [];
+		items.forEach((item, index) => {
+			const settlement = expansion.settlements[index];
+			if (settlement?.outcome === "delivered") results.push({
+				index,
+				item,
+				result: settlement.result
+			});
+			else failures.push({
+				index,
+				item,
+				outcome: settlement?.outcome ?? "unpropagated",
+				reason: settlement?.reason ?? "never settled"
+			});
+		});
+		const refusal = closed ?? (route.onItemFailure === "all-or-refuse" && failures.length > 0 ? `all-or-refuse: ${failures.length} of ${items.length} items did not deliver (${failures.map((failure) => `#${failure.index} ${failure.outcome}: ${failure.reason}`).join("; ")}); the join did not run` : void 0);
+		if (refusal !== void 0) {
+			await publishMap({
+				edge: route.edge,
+				phase: "join",
+				outcome: "unpropagated",
+				sourceWorker,
+				bytes: 0,
+				reason: refusal
+			}, closed === void 0);
+			return;
+		}
+		const task = {
+			map: route.edge,
+			source: sourceWorker,
+			items: items.length,
+			results,
+			failures
+		};
+		const started = await startMapSpawn(expansion, "join", route.join, task, void 0);
+		if ("refused" in started) await publishMap({
+			edge: route.edge,
+			phase: "join",
+			outcome: "unpropagated",
+			sourceWorker,
+			bytes: 0,
+			reason: `join spawn refused: ${started.refused}`
+		}, true);
+	};
+	const settleMapMember = async (settled, worker, advance) => {
+		const member = mapMembers.get(worker.id);
+		if (member === void 0) return;
+		mapMembers.delete(worker.id);
+		const { expansion, role, index, bytes } = member;
+		const settlement = mapSettlement(settled, worker);
+		await publishMap({
+			edge: expansion.route.edge,
+			phase: role,
+			outcome: settlement.outcome,
+			sourceWorker: expansion.sourceWorker,
+			...index === void 0 ? {} : { index },
+			workerId: worker.id,
+			bytes,
+			...settlement.reason === void 0 ? {} : { reason: settlement.reason }
+		});
+		if (role === "join" || index === void 0) return;
+		expansion.inFlight -= 1;
+		expansion.settlements[index] = settlement;
+		if (settlement.outcome !== "delivered" && expansion.route.onItemFailure === "all-or-refuse") expansion.stopped = true;
+		if (advance) await pumpMap(expansion);
+		else if (expansion.inFlight === 0) await finishMap(expansion, "not started: the manager stopped before this map finished");
+	};
+	const expandMaps = async (settled, worker) => {
+		if (settled.kind !== "done" || mapRoutes.length === 0) return;
+		const name = profileNameByWorker.get(worker.id);
+		for (const route of mapRoutes) {
+			if (route.from !== name) continue;
+			const refuse = (reason) => publishMap({
+				edge: route.edge,
+				phase: "expand",
+				outcome: "unpropagated",
+				sourceWorker: worker.id,
+				bytes: 0,
+				reason
+			}, true);
+			const selected = resolveJsonPointer(settled.out, route.pointer);
+			if (!selected.found) {
+				await refuse(`pointer ${JSON.stringify(route.pointer)} does not resolve in the source result: ${selected.reason}; no item ran`);
+				continue;
+			}
+			const items = selected.value;
+			if (!Array.isArray(items)) {
+				await refuse(`pointer ${JSON.stringify(route.pointer)} resolves to ${items === null ? "null" : typeof items}, not an array; no item ran`);
+				continue;
+			}
+			if (items.length > route.maxItems) {
+				await refuse(`max-items-exceeded: the list holds ${items.length} items and this map admits at most ${route.maxItems}; no item ran`);
+				continue;
+			}
+			const slots = workerSlotBound();
+			if (slots !== void 0 && route.concurrency > slots) {
+				await refuse(`concurrency-unsatisfiable: concurrency ${route.concurrency} exceeds this run's ${slots} worker slots, so the cap could never be honored; no item ran`);
+				continue;
+			}
+			await publishMap({
+				edge: route.edge,
+				phase: "expand",
+				outcome: items.length === 0 ? "empty" : "delivered",
+				sourceWorker: worker.id,
+				bytes: textBytes(items),
+				items: items.length,
+				...items.length === 0 ? { reason: "the list is empty; the join runs with no results" } : {}
+			});
+			await pumpMap({
+				route,
+				sourceWorker: worker.id,
+				items: detachedFrozen(items),
+				settlements: [],
+				next: 0,
+				inFlight: 0,
+				stopped: false,
+				finished: false
+			});
+		}
+	};
+	const runMapStep = async (step, worker) => {
+		try {
+			await step();
+		} catch (error) {
+			console.error("Runtime map step failed", {
+				managerId: opts.scope.view.root,
+				worker: worker.id,
+				error: errMessage(error)
+			});
+		}
+	};
 	let flushing = 0;
 	const flushPendingSettlement = async () => {
 		flushing += 1;
@@ -1355,7 +1634,8 @@ function createCoordinationToolsForManager(opts, lifetime) {
 	const flushPendingSettlementOnce = async () => {
 		const pending = pendingSettlement;
 		if (!pending) return false;
-		await bus.publish(pending.event);
+		if (mapMembers.get(pending.worker.id)?.role === "item") await bus.publish(pending.event, { queue: false });
+		else await bus.publish(pending.event);
 		if (pending.analystRun) {
 			analystRuns.delete(pending.worker.id);
 			flushedAnalystRuns.add(pending.worker.id);
@@ -1370,6 +1650,8 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		}
 		commitSettled(pending.worker);
 		pendingSettlement = void 0;
+		const advance = pending.analyze && !finishingAnalysis;
+		await runMapStep(() => settleMapMember(pending.settled, pending.worker, advance), pending.worker);
 		if (pending.analyze && !finishingAnalysis && analysisRoutes.length) {
 			const sourceNames = workerRouteNames(pending.worker.id);
 			const applicable = analysisRoutes.filter((route) => route.at !== "manager-end" && (route.statuses ?? ["done"]).includes(pending.worker.status) && (route.over === void 0 || route.over.some((name) => sourceNames.has(name))));
@@ -1404,6 +1686,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			}
 			for (const route of agentRoutes) await spawnAnalystRun(route, pending.worker);
 		}
+		if (advance) await runMapStep(() => expandMaps(pending.settled, pending.worker), pending.worker);
 		return true;
 	};
 	const drainSettlement = async (source = "next") => {
@@ -1638,6 +1921,10 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			type: "lead-message",
 			...ev.message
 		};
+		if (ev.type === "map") return {
+			type: "map",
+			...ev.map
+		};
 		return {
 			type: ev.type,
 			...ev.down
@@ -1927,6 +2214,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		status: node.status,
 		...node.assignmentId === void 0 ? {} : { assignmentId: node.assignmentId },
 		...node.identity === void 0 ? {} : { identity: node.identity },
+		...node.modelSubstitution === void 0 ? {} : modelSubstitutionReport(node.modelSubstitution),
 		...node.materialization === void 0 ? {} : { materialization: node.materialization },
 		...node.executionBindings === void 0 ? {} : { executionBindings: node.executionBindings },
 		spent: node.spent,
@@ -1945,7 +2233,8 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			queued: bus.queued([
 				"settled",
 				"finding",
-				"lead-message"
+				"lead-message",
+				"map"
 			])
 		};
 	};
@@ -2099,14 +2388,19 @@ function createCoordinationToolsForManager(opts, lifetime) {
 		const { running, unqueued, queued } = openWork();
 		return running.length > 0 || unqueued.length > 0 || queued.length > 0 || bus.pending(wakeEventKinds) > 0 || openReceipts.size > 0 || leadPublishing > 0 || pendingSettlement !== void 0 || flushing > 0;
 	};
+	const liveWorkersProgressing = () => {
+		const running = openWork().running;
+		return running.length > 0 && running.every((node) => readProgress(node.id)?.stalled === false);
+	};
 	const awaitWake = async (input) => {
 		const startedAt = Date.now();
+		let quietHeartbeats = 0;
 		await ready();
 		await settledWithoutDrain();
 		if (!hasOpenWork() || input.signal.aborted) return void 0;
-		const heartbeatAt = startedAt + Math.max(0, input.heartbeatMs);
+		let heartbeatAt = startedAt + Math.max(0, input.heartbeatMs);
 		const deadlineAt = input.deadlineAt ?? Number.POSITIVE_INFINITY;
-		const wakeAt = Math.min(heartbeatAt, deadlineAt);
+		let wakeAt = Math.min(heartbeatAt, deadlineAt);
 		let unsubscribe;
 		let timer;
 		let onAbort;
@@ -2117,9 +2411,14 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					if (wakeEventKinds.includes(record.event.type)) resolve();
 				});
 			});
-			const elapsed = new Promise((resolve) => {
-				timer = setTimeout(resolve, Math.max(0, wakeAt - Date.now()));
-			});
+			let elapsed = Promise.resolve();
+			const armTimer = () => {
+				if (timer) clearTimeout(timer);
+				elapsed = new Promise((resolve) => {
+					timer = setTimeout(resolve, Math.max(0, wakeAt - Date.now()));
+				});
+			};
+			armTimer();
 			const aborted = new Promise((resolve) => {
 				onAbort = () => resolve();
 				input.signal.addEventListener("abort", onAbort, { once: true });
@@ -2128,18 +2427,28 @@ function createCoordinationToolsForManager(opts, lifetime) {
 				outsideWake = true;
 			});
 			let cursorIdle = false;
-			while (bus.pending(wakeEventKinds) === 0 && !outsideWake && !input.signal.aborted && Date.now() < wakeAt) {
-				const drained = !cursorIdle && openWork().running.length > 0 ? ensureDrain() : new Promise(() => void 0);
-				if (await Promise.race([
-					drained.then((value) => value ? "drained" : "idle"),
-					queuedEvent.then(() => "queued"),
-					elapsed.then(() => "elapsed"),
-					aborted.then(() => "aborted"),
-					outside.then(() => "outside")
-				]) === "idle") {
-					cursorIdle = true;
-					if (!hasOpenWork()) break;
+			for (;;) {
+				while (bus.pending(wakeEventKinds) === 0 && !outsideWake && !input.signal.aborted && Date.now() < wakeAt) {
+					const drained = !cursorIdle && openWork().running.length > 0 ? ensureDrain() : new Promise(() => void 0);
+					if (await Promise.race([
+						drained.then((value) => value ? "drained" : "idle"),
+						queuedEvent.then(() => "queued"),
+						elapsed.then(() => "elapsed"),
+						aborted.then(() => "aborted"),
+						outside.then(() => "outside")
+					]) === "idle") {
+						cursorIdle = true;
+						if (!hasOpenWork()) break;
+					}
+				}
+				if (input.quietWhileProgressing === true && input.heartbeatMs > 0 && bus.pending(wakeEventKinds) === 0 && !outsideWake && !input.signal.aborted && Date.now() >= heartbeatAt && Date.now() < deadlineAt && liveWorkersProgressing()) {
+					quietHeartbeats += 1;
+					heartbeatAt = Date.now() + input.heartbeatMs;
+					wakeAt = Math.min(heartbeatAt, deadlineAt);
+					armTimer();
+					continue;
 				}
+				break;
 			}
 			if (input.signal.aborted) return void 0;
 			if (flushing > 0 && inFlightDrain !== null) await inFlightDrain.catch(() => false);
@@ -2175,7 +2484,8 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			events,
 			live: liveSnapshot(),
 			freeSlots: freeWorkerSlots(),
-			idleMs: Date.now() - startedAt
+			idleMs: Date.now() - startedAt,
+			...quietHeartbeats === 0 ? {} : { quietHeartbeats }
 		});
 	};
 	const admitSpawn = async (input) => {
@@ -2214,7 +2524,8 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			continuity: continuity.continuity,
 			...continuity.continuity === "resume" ? { resume: continuity.resume } : {},
 			...successorOf !== void 0 ? { successorOf } : {},
-			...peerMailUrl !== void 0 ? { peerMailUrl } : {}
+			...peerMailUrl !== void 0 ? { peerMailUrl } : {},
+			...input.map !== void 0 ? { map: input.map } : {}
 		});
 		const res = opts.scope.spawn(() => opts.makeWorkerAgent(profile, context), task, {
 			budget,
@@ -2254,6 +2565,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 			workerId: res.handle.id,
 			assignmentId: res.handle.assignmentId ?? assignmentId,
 			...res.handle.identity === void 0 ? {} : { identity: res.handle.identity },
+			...res.handle.modelSubstitution === void 0 ? {} : modelSubstitutionReport(res.handle.modelSubstitution),
 			...res.handle.materialization === void 0 ? {} : { materialization: res.handle.materialization },
 			...res.handle.executionBindings === void 0 ? {} : { executionBindings: res.handle.executionBindings },
 			continuity: continuity.continuity,
@@ -3486,6 +3798,36 @@ function nextUnkeyedAssignmentOrdinal(scope) {
 	if (!Number.isSafeInteger(next)) throw new Error("coordination: durable assignment ordinal space is exhausted");
 	return next;
 }
+/** Resolve an RFC 6901 JSON pointer (`''` is the whole document). */
+function resolveJsonPointer(document, pointer) {
+	if (pointer === "") return {
+		found: true,
+		value: document
+	};
+	if (!pointer.startsWith("/")) return {
+		found: false,
+		reason: "a JSON pointer is empty or starts with \"/\""
+	};
+	let value = document;
+	for (const raw of pointer.slice(1).split("/")) {
+		const token = raw.replaceAll("~1", "/").replaceAll("~0", "~");
+		if (Array.isArray(value)) {
+			if (!/^(0|[1-9]\d*)$/.test(token) || Number(token) >= value.length) return {
+				found: false,
+				reason: `no index ${JSON.stringify(token)} in an array of ${value.length}`
+			};
+			value = value[Number(token)];
+		} else if (typeof value === "object" && value !== null && Object.hasOwn(value, token)) value = value[token];
+		else return {
+			found: false,
+			reason: `no member ${JSON.stringify(token)}`
+		};
+	}
+	return {
+		found: true,
+		value
+	};
+}
 /** Stringify a findings payload for a routed delivery; never throws (a cyclic payload degrades to
 *  its String form rather than killing the settle path). */
 function safeJsonText(value) {
@@ -4719,6 +5061,7 @@ function driverAgent(opts) {
 				...opts.deliverable ? { deliverable: opts.deliverable } : {},
 				...opts.analysts ? { analysts: opts.analysts } : {},
 				...opts.analyzeOnSettle ? { analyzeOnSettle: opts.analyzeOnSettle } : {},
+				...opts.mapOnSettle ? { mapOnSettle: opts.mapOnSettle } : {},
 				...opts.sourceEvidenceRefs ? { sourceEvidenceRefs: opts.sourceEvidenceRefs } : {},
 				...opts.peerAudit ? { peerAudit: opts.peerAudit } : {},
 				...opts.watchWorkers ? { watchWorkers: opts.watchWorkers } : {},
@@ -4967,6 +5310,7 @@ function driverAgent(opts) {
 							wake = await coord.awaitWake({
 								signal: scope.signal,
 								heartbeatMs: wakePolicy.heartbeatMs,
+								quietWhileProgressing: true,
 								debounceMs: wakePolicy.debounceMs,
 								...warnAt === void 0 ? {} : { deadlineAt: warnAt },
 								alsoWakeOn: inbox.pending() > 0 ? Promise.resolve() : inbox.nextDelivery()
@@ -5122,4 +5466,4 @@ function safeJson(v) {
 //#endregion
 export { ANALYST_DEFINITION_BOUNDS as A, createEventBus as B, createFileRunContext as C, foldCoordinationRecords as D, FileCoordinationLog as E, createCoordinationToolsForManager as F, watchTrace as H, downMessageRefusalReasons as I, normalizeAnalyzeOnSettle as L, canonicalFindingEvent as M, coordinationVerbNames as N, applyRunCancellation as O, createCoordinationTools as P, parseAuthoredAnalystDefinition as R, renderAnytimeTable as S, withRunContext as T, defaultToolDetectors as V, sampleFromSettled as _, DEFAULT_DEADLINE_WARNING_MS as a, bestSoFar as b, refreshedWake as c, allWorkersStalled as d, anyOf as f, progressStop as g, plateau as h, finalizeBestDelivered as i, analystToolGroupNames as j, watchRunCancellation as k, resolveWakePolicy as l, noProgressFor as m, createSteerAcknowledger as n, composeWakeInput as o, createProgressTracker as p, driverAgent as r, deadlineWarningAt as s, createCancelAcknowledger as t, allOf as u, anytimeReport as v, createInMemoryRunContext as w, plateauLength as x, areaUnderCurve as y, questionEscalationTargets as z };
 
-//# sourceMappingURL=coordination-driver-Cd0KpYoT.js.map
+//# sourceMappingURL=coordination-driver-DsxFmzhm.js.map