@tangle-network/agent-runtime 0.259.1 → 0.262.0

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

@@ -1,4 +1,4 @@
-import { $r as readCommittedJsonLines, Cn as runBrainLoop, Kt as createInbox, Ot as parseWorkerToolTraceArtifact, Qi as addResourceSpend, Qr as prepareJsonlAppend, R as scopeRetainedOwnerResourceReader, Ri as chargedTokens, U as resolveSpawnResourcePaths, Ui as promptCacheTokenClasses, Xn as resolveRedactor, Yi as unmeteredSpend, Zt as createPeerMailbox, _t as FileSpawnJournal, a as pickBestDelivered, ea as withBudgetResources, ei as writeAllBytes, et as errMessage, g as withDriverExecutor, gt as FileResultBlobStore, jt as assertValidBudget, kt as workerTraceAnalysisStore, li as providerAttemptEvidence, nn as isTerminalNodeStatus, nt as freeSlots, o as runFinalizer, r as bestDelivered, s as runTree, tn as isLiveNodeStatus, ut as createExecutorRegistry, vt as InMemoryResultBlobStore, x as meterRuntimeOwnedProviderAttempt, xi as detachedFrozen, yt as InMemorySpawnJournal } from "./supervisor-CJyzUjc7.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",
@@ -713,6 +722,33 @@ function spawnProfileArg() {
 	}).properties));
 	return spawnProfileArgCache;
 }
+/** `spawn_worker`'s `profile` argument when the run has a profiles table: one of the table's names,
+*  listed with each entry's description and whether a sealed verdict promoted it, or a profile the
+*  manager authors. Without a table the argument is the authored shape alone, byte for byte. */
+function spawnProfileArgWithTable(profiles) {
+	const menu = [...profiles].map(([name, entry]) => {
+		return `- '${name}'${typeof entry.profile.description === "string" && entry.profile.description.length > 0 ? ` — ${entry.profile.description}` : ""} (${entry.promotion ? `promoted by sealed play ${JSON.stringify(entry.promotion.experiment.spec.id)}` : "exploratory"})`;
+	});
+	return { anyOf: [{
+		type: "string",
+		enum: [...profiles.keys()],
+		description: `The name of a profile in this run's profiles table. The runtime runs that exact profile, so do not retype it; other profile fields cannot be added to a name. Promoted entries beat their control in a sealed comparison; exploratory ones have no verdict yet.\n${menu.join("\n")}`
+	}, spawnProfileArg()] };
+}
+/** Why `spawn_worker` cannot use this `profile` argument against the profiles table, or
+*  `undefined` when it can. A name must be in the table. An authored profile must not take a table
+*  name: continuity and every per-name record key on `profile.name`, so one name must mean one
+*  profile. Without a table nothing is refused here, and the canonical schema answers as before. */
+function profileTableRefusal(table, profile) {
+	if (table === void 0) return void 0;
+	if (typeof profile === "string") {
+		if (table.has(profile)) return void 0;
+		return `profile ${JSON.stringify(profile)} is not in this run's profiles table, which holds ${[...table.keys()].map((name) => JSON.stringify(name)).join(", ")}`;
+	}
+	const name = typeof profile === "object" && profile !== null ? profile.name : void 0;
+	if (typeof name !== "string" || !table.has(name)) return void 0;
+	return `profile.name ${JSON.stringify(name)} is a profiles-table entry: pass profile: ${JSON.stringify(name)} to run that exact profile, or give the profile you wrote another name`;
+}
 const BUDGET_FIELD = {
 	tokens: "maxTokens",
 	iterations: "maxIterations",
@@ -763,6 +799,7 @@ function createCoordinationTools(opts) {
 /** Internal manager binding; its lifetime fences delivery without cancelling the worker scope. */
 function createCoordinationToolsForManager(opts, lifetime) {
 	const deliverable = opts.deliverable;
+	const profileTable = opts.profiles !== void 0 && opts.profiles.size > 0 ? opts.profiles : void 0;
 	const readWorkerOutput = createWorkerOutputReader(opts.blobs);
 	const priorSubmission = deliverable === void 0 ? void 0 : opts.priorJournal?.find((record) => record.event.type === "submission");
 	let stopped = priorSubmission !== void 0;
@@ -770,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 ?? []];
@@ -856,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`);
@@ -1118,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;
@@ -1369,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
@@ -1579,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: {
@@ -1673,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;
@@ -1756,11 +1855,11 @@ function createCoordinationToolsForManager(opts, lifetime) {
 	const tools = [
 		{
 			name: "spawn_worker",
-			description: "Start a worker the driver will drive. `profile` is the worker or another driver; `task` is what it should do. Reserves budget from the conserved pool and fails closed. Pass an optional `budget` (per-field) to give a hard sub-task more than the default — it merges over the per-worker default; the conserved pool is still the hard fence. When a max-live-workers cap is set it also fails closed (`error: \"max-live-workers\"`) while that many workers are still in flight — settle or steer one before spawning another. Pass a `key` naming the assignment to make it run-once ACROSS restarts: a key that already completed returns the finished result (`resumed: \"completed\"` — no work re-runs, nothing is spent), a key whose prior attempt failed (`down`) spawns fresh and says so (`resumed: \"retried\"`), and a key with no terminal receipt is refused (`error: \"in-doubt\"`) until its exact prior execution is recovered. A key still running is refused (`error: \"duplicate-key\"`). Returns `freeSlots`: how many MORE workers you can start right now (`null` = uncapped). While `freeSlots > 0` there is idle capacity — call this again to fill it rather than waiting; parallel workers finish the run sooner than one at a time.",
+			description: "Start a worker the driver will drive. `profile` is the worker or another driver; `task` is what it should do. Reserves budget from the conserved pool and fails closed. Pass an optional `budget` (per-field) to give a hard sub-task more than the default — it merges over the per-worker default; the conserved pool is still the hard fence. When a max-live-workers cap is set it also fails closed (`error: \"max-live-workers\"`) while that many workers are still in flight — settle or steer one before spawning another. Pass a `key` naming the assignment to make it run-once ACROSS restarts: a key that already completed returns the finished result (`resumed: \"completed\"` — no work re-runs, nothing is spent), a key whose prior attempt failed (`down`) spawns fresh and says so (`resumed: \"retried\"`), and a key with no terminal receipt is refused (`error: \"in-doubt\"`) until its exact prior execution is recovered. A key still running is refused (`error: \"duplicate-key\"`). Returns `freeSlots`: how many MORE workers you can start right now (`null` = uncapped). While `freeSlots > 0` there is idle capacity — call this again to fill it rather than waiting; parallel workers finish the run sooner than one at a time." + (profileTable === void 0 ? "" : " This run has a profiles table: pass `profile` as one of the table's names to run that exact profile, or write a new profile under a name the table does not hold."),
 			inputSchema: {
 				type: "object",
 				properties: {
-					profile: spawnProfileArg(),
+					profile: profileTable === void 0 ? spawnProfileArg() : spawnProfileArgWithTable(profileTable),
 					task: { description: "The task the worker should perform." },
 					label: {
 						type: "string",
@@ -1775,6 +1874,10 @@ function createCoordinationToolsForManager(opts, lifetime) {
 						enum: ["fresh", "resume"],
 						description: "How this spawn continues the node's prior work. \"fresh\" (the default) starts a brand-new session. \"resume\" re-attaches to the node's most recent SETTLED worker: a NEW live worker is spawned whose session continues where that worker stopped (the backend receives the prior workerId and the resume sequence). Resume fails closed when the node has no settled prior worker (`error: \"resume-no-prior\"` — spawn it fresh first), while a prior worker of the node is still live (`error: \"resume-while-live\"` — steer_agent is the live-worker channel), and under a `key` (`error: \"resume-with-key\"` — keys are run-once, resume runs again). Omit to use the run's declared default for this profile name."
 					},
+					successorOf: {
+						type: "string",
+						description: "The workerId of a SETTLED worker you spawned that this new worker replaces — for example one that failed, stalled, or finished with a weak result, restarted with a changed profile or task. The run record then names the predecessor on the new worker. Refused for an id you did not spawn (`error: \"successor-unknown\"`) and for a worker still live (`error: \"successor-live\"` — await_event until it settles). Put what the successor needs from its predecessor in `task`."
+					},
 					budget: {
 						type: "object",
 						description: "Optional per-spawn budget that merges over the per-worker default (per field). Only set the ceilings this sub-task needs raised; the conserved pool still fences.",
@@ -1827,7 +1930,21 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					live,
 					freeSlots: freeWorkerSlots()
 				}))(liveWorkerCount()));
-				const resourcePaths = await resolveSpawnResourcePaths(a.profile, opts.spawnResourceReader ?? opts.spawnResourceRoot);
+				const tableRefusal = profileTableRefusal(profileTable, a.profile);
+				if (tableRefusal !== void 0) return {
+					error: "invalid-profile",
+					reason: tableRefusal,
+					issues: [{
+						path: "profile",
+						message: tableRefusal
+					}]
+				};
+				const tableEntry = typeof a.profile === "string" ? profileTable?.get(a.profile) : void 0;
+				const resourcePaths = tableEntry === void 0 ? await resolveSpawnResourcePaths(a.profile, opts.spawnResourceReader ?? opts.spawnResourceRoot) : {
+					ok: true,
+					profile: tableEntry.profile,
+					resolved: []
+				};
 				if (!resourcePaths.ok) return {
 					error: "invalid-profile",
 					reason: `resources.${resourcePaths.at}: ${resourcePaths.reason}`,
@@ -1854,6 +1971,22 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					live: liveWorkerCount(),
 					freeSlots: freeWorkerSlots()
 				});
+				const successorOf = a.successorOf === void 0 ? void 0 : str(a.successorOf, "successorOf");
+				if (successorOf !== void 0) {
+					const predecessor = nodeForWorker(successorOf);
+					if (predecessor === void 0 || predecessor.parent !== opts.scope.view.root) return {
+						error: "successor-unknown",
+						reason: `'${successorOf}' is not a worker this manager spawned — successorOf takes a workerId from one of your own spawn_worker results`,
+						live: liveWorkerCount(),
+						freeSlots: freeWorkerSlots()
+					};
+					if (isLiveNodeStatus(predecessor.status)) return {
+						error: "successor-live",
+						reason: `worker '${successorOf}' has not settled — await_event until it does, then spawn its successor (steer_agent redirects a live worker instead)`,
+						live: liveWorkerCount(),
+						freeSlots: freeWorkerSlots()
+					};
+				}
 				const task = detachedFrozen(a.task);
 				const label = typeof a.label === "string" ? a.label : "worker";
 				if (opts.preflightSpawn) {
@@ -1887,13 +2020,15 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					...key !== void 0 ? { key } : {},
 					continuity: continuity.continuity,
 					...continuity.continuity === "resume" ? { resume: continuity.resume } : {},
+					...successorOf !== void 0 ? { successorOf } : {},
 					...peerMailUrl !== void 0 ? { peerMailUrl } : {}
 				});
 				const res = opts.scope.spawn(() => opts.makeWorkerAgent(profile, context), task, {
 					budget,
 					label,
 					assignmentId,
-					...key !== void 0 ? { key } : {}
+					...key !== void 0 ? { key } : {},
+					...successorOf !== void 0 ? { successorOf } : {}
 				});
 				if (res.ok && res.prior?.state === "completed") {
 					const s = res.prior.settled;
@@ -1932,6 +2067,7 @@ function createCoordinationToolsForManager(opts, lifetime) {
 					...res.handle.executionBindings === void 0 ? {} : { executionBindings: res.handle.executionBindings },
 					continuity: continuity.continuity,
 					...continuity.continuity === "resume" ? { resume: continuity.resume } : {},
+					...successorOf !== void 0 ? { successorOf } : {},
 					live: liveWorkerCount(),
 					freeSlots: freeWorkerSlots(),
 					...priorHistory,
@@ -2045,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());
@@ -2071,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()
 				};
 			}
@@ -2253,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;
@@ -2271,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 }
 					};
 				}
@@ -2307,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",
@@ -2336,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;
@@ -2343,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: [
@@ -2563,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];
@@ -3273,13 +3614,13 @@ function formatOverspend(violation) {
 *  (can't afford a worker) and usd (a usd-capped pool whose ceiling the driver's own metered
 *  inference has drained — `meter` debits usd, so without this a huge-token/small-usd pool would
 *  overspend usd up to the turn tripwire). */
-function poolStarved(scope, perWorker) {
+function poolStarved(scope, perWorker, preserveOwnerTurns = false) {
 	const b = scope.budget;
 	if (scope.view.inFlight > 0 || scope.view.waiting > 0) return false;
-	const tokenStarved = b.tokensLeft < perWorker.maxTokens;
+	const tokenStarved = preserveOwnerTurns ? b.tokensLeft <= 0 : b.tokensLeft < perWorker.maxTokens;
 	const iterationStarved = b.iterationsLeft <= 0;
-	const usdStarved = b.usdCapped && (b.usdLeft <= 0 || perWorker.maxUsd !== void 0 && b.usdLeft < perWorker.maxUsd);
-	const resourceStarved = Object.entries(b.resources ?? {}).some(([name, value]) => !value.known || value.remaining <= 0 || value.remaining < (perWorker.resources?.[name]?.limit ?? 0));
+	const usdStarved = b.usdCapped && (b.usdLeft <= 0 || !preserveOwnerTurns && perWorker.maxUsd !== void 0 && b.usdLeft < perWorker.maxUsd);
+	const resourceStarved = Object.entries(b.resources ?? {}).some(([name, value]) => !value.known || value.remaining <= 0 || !preserveOwnerTurns && value.remaining < (perWorker.resources?.[name]?.limit ?? 0));
 	return tokenStarved || iterationStarved || usdStarved || resourceStarved;
 }
 /** The absolute wall-clock deadline (when the root set one) has passed. */
@@ -3680,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,
@@ -3697,6 +4039,7 @@ function driverAgent(opts) {
 				...opts.preflightSpawn ? { preflightSpawn: opts.preflightSpawn } : {},
 				...opts.resolveSpawnProfile ? { resolveSpawnProfile: opts.resolveSpawnProfile } : {},
 				...opts.composeSpawnProfile ? { composeSpawnProfile: opts.composeSpawnProfile } : {},
+				...opts.profiles ? { profiles: opts.profiles } : {},
 				...opts.spawnResourceRoot ? { spawnResourceRoot: opts.spawnResourceRoot } : {},
 				...ownerReader ? { spawnResourceReader: ownerReader } : {},
 				...opts.escalateQuestion ? { escalateQuestion: opts.escalateQuestion } : {},
@@ -3705,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 ?? []];
@@ -3725,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({
@@ -3905,7 +4250,7 @@ function driverAgent(opts) {
 						});
 					},
 					stopBefore: () => {
-						if (coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker) || deadlinePassed(scope, now)) return true;
+						if (coord.isStopped() || scope.signal.aborted || poolStarved(scope, opts.perWorker, opts.preserveOwnerTurns) || deadlinePassed(scope, now)) return true;
 						if (!opts.stopRule || !tracker) return false;
 						const decision = progressStop(tracker, opts.stopRule, coord, scope, now, opts.stallAfterMs);
 						if (!decision.stop) return false;
@@ -4036,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-BmtrkNPu.js.map
+//# sourceMappingURL=coordination-driver-COGC8FK2.js.map