@tangle-network/agent-runtime 6.0.8 → 8.0.0

package/dist/{coordination-manager-D9z7To7p.js → coordination-manager-sa_PkISw.js}

@@ -1,14 +1,16 @@
-import { $t as FileResultBlobStore, B as FileSpawnJournal, C as writeWorkerSteerAcknowledgement, H as spawnJournalRecordEvents, M as workerTraceAnalysisStore, Pt as runtimeGraphMetadataKey, et as meterRuntimeOwnedAccounting, f as readWorkerCancelRequests, h as readWorkerSteerRequests, j as parseWorkerToolTraceArtifact, l as claimWorkerSteerDelivery, m as readWorkerSteerAcknowledgement, or as isLiveNodeStatus, p as readWorkerCancellation, sr as isTerminalNodeStatus, vt as resolveSpawnResourcePaths, x as writeWorkerCancellation } from "./scope-gIYQ5ZiL.js";
-import { $ as assertValidBudget, M as contentAddress, o as settlementFailureCause } from "./failure-cause-BzjUUsRz.js";
-import { a as errMessage, d as resolveRedactor, t as detachedFrozen } from "./snapshot-Cgj2Wzi6.js";
-import { Et as failedItems, Y as INBOX_RECEIPT_KEY, _ as withDriverExecutor, b as createExecutorRegistry, gt as CheckUnavailableError, nt as createPeerMailbox, v as InMemoryResultBlobStore, wt as checkVerdictOf, y as InMemorySpawnJournal } from "./supervisor-1A27fE6k.js";
-import { c as writeRunCancellation, i as readRunCancellation, r as readRunCancelRequest, t as applyRunCancellation, v as FileCoordinationLog } from "./run-cancellation-D_4vJ522.js";
-import { a as admitRuntimeSpawn, i as workerSettlement, n as resolveJsonPointer, o as safeJsonText, r as textBytes, t as createMapRouting } from "./coordination-map-routing-CKRNZSaV.js";
-import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
+import { E as writeWorkerCancellation, F as parseWorkerToolTraceArtifact, I as workerTraceAnalysisStore, K as spawnJournalRecordEvents, O as writeWorkerSteerAcknowledgement, Rt as runtimeGraphMetadataKey, S as workerCancelRequestsFile, St as resolveSpawnResourcePaths, T as workerSteerRequestsDir, W as FileSpawnJournal, _ as readWorkerSteerAcknowledgement, d as claimWorkerSteerDelivery, dr as isLiveNodeStatus, fr as isTerminalNodeStatus, g as readWorkerCancellation, h as readWorkerCancelRequests, in as FileResultBlobStore, it as meterRuntimeOwnedAccounting, v as readWorkerSteerRequests } from "./supervisor-accounting-Bw4MJk-b.js";
+import { m as ValidationError } from "./errors-DG8yufqX.js";
+import { M as contentAddress, et as assertValidBudget, o as settlementFailureCause } from "./failure-cause-CVB-YE88.js";
+import { a as errMessage, f as resolveRedactor, t as detachedFrozen } from "./snapshot-BKI_w3JD.js";
+import { Y as INBOX_RECEIPT_KEY, _ as withDriverExecutor, b as createExecutorRegistry, gt as CheckUnavailableError, nt as createPeerMailbox, v as InMemoryResultBlobStore, y as InMemorySpawnJournal } from "./supervisor-Dpeu7rnZ.js";
+import { i as checkVerdictOf, o as failedItems } from "./continuation-CIyKnS1Q.js";
+import { c as writeRunCancellation, i as readRunCancellation, r as readRunCancelRequest, t as applyRunCancellation, v as FileCoordinationLog } from "./run-cancellation-DYszFJtQ.js";
+import { a as admitRuntimeSpawn, i as workerSettlement, n as resolveJsonPointer, o as safeJsonText, r as textBytes, t as createMapRouting } from "./coordination-map-routing-XZXTlCmn.js";
+import { ResourceRequestSchema, agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { argHash, errorStreakDetector, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
 import { registry } from "zod";
 import { randomUUID } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
 import { join } from "node:path";
 // src/runtime/supervise/run-context.ts
 /**
@@ -112,6 +114,7 @@ const journalEventKinds = [
 	"analyst-assignment",
 	"acknowledgement",
 	"tool-outcome",
+	"tool-timing",
 	"lead-message",
 	"map",
 	"route"
@@ -484,18 +487,62 @@ const BUDGET_FIELD = {
 	usd: "maxUsd"
 };
 // src/runtime/supervise/driver-control-acknowledgers.ts
-/** The journal file `createFileRunContext` writes inside the run directory. The acknowledger
-*  reads it as EVIDENCE for the terminated-descendants set — the nested trees of a cancelled
-*  lead journal their terminal records there before the lead settles into this scope. */
 const SPAWN_JOURNAL_FILE = "spawn-journal.jsonl";
-/**
-* Apply externally admitted steers once through the owning manager's control path.
-*
-* The `unknown` acknowledgement lands before authorization or delivery. A crash after that write
-* can lose this steer, but a restarted manager never delivers it again. This is the same
-* at-most-once crash boundary as coordination instruction receipts: no duplicate instruction is
-* safer than replaying a mutation whose first delivery may already have succeeded.
-*/
+function appendedLines(tail) {
+	let size;
+	try {
+		size = statSync(tail.file).size;
+	} catch {
+		return;
+	}
+	if (size < tail.offset) {
+		tail.offset = 0;
+		tail.partial = "";
+		tail.at.clear();
+	}
+	if (size === tail.offset) return void 0;
+	const buf = Buffer.allocUnsafe(size - tail.offset);
+	const fd = openSync(tail.file, "r");
+	try {
+		const got = readSync(fd, buf, 0, buf.length, tail.offset);
+		tail.offset += got;
+		const text = tail.partial + buf.subarray(0, got).toString("utf8");
+		const parts = text.split("\n");
+		tail.partial = text.endsWith("\n") ? "" : parts.pop() ?? "";
+		if (text.endsWith("\n")) parts.pop();
+		return parts;
+	} finally {
+		closeSync(fd);
+	}
+}
+function indexDeaths(tail) {
+	const lines = appendedLines(tail);
+	if (lines === void 0) return false;
+	let grew = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			for (const event of spawnJournalRecordEvents(JSON.parse(trimmed))) {
+				if (event === void 0) continue;
+				if (!(event.kind === "settled" && event.status === "down" || event.kind === "cancelled") || typeof event.id !== "string" || typeof event.at !== "string") continue;
+				const prev = tail.at.get(event.id);
+				if (prev !== void 0 && prev >= event.at) continue;
+				tail.at.set(event.id, event.at);
+				grew = true;
+			}
+		} catch {}
+	}
+	return grew;
+}
+function descendantsSince(tail, nodeId, sinceIso) {
+	indexDeaths(tail);
+	const prefix = `${nodeId}:`;
+	const ids = [...tail.at.keys()].filter((id) => id.startsWith(prefix) && (tail.at.get(id) ?? "") >= sinceIso);
+	ids.sort();
+	return ids;
+}
+/** Unknown ack lands before delivery. A crash can lose the steer; a restart must not deliver it twice. */
 function createSteerAcknowledger(deps) {
 	const iso = () => new Date(deps.now()).toISOString();
 	const awaiting = /* @__PURE__ */ new Map();
@@ -520,9 +567,29 @@ function createSteerAcknowledger(deps) {
 		worker: request.worker,
 		requestedAt: request.at
 	});
+	let steerStamp = "";
+	let steerIdle = false;
+	const steerChanged = (phase) => {
+		let stamp = "missing";
+		try {
+			const st = statSync(workerSteerRequestsDir(deps.dir), { bigint: true });
+			stamp = `${st.dev}:${st.ino}:${st.mtimeNs}:${st.size}`;
+		} catch {
+			stamp = "missing";
+		}
+		const changed = stamp !== steerStamp;
+		if (changed && phase !== "boundary") steerStamp = stamp;
+		return changed;
+	};
 	return { async pass(phase) {
+		const changed = steerChanged(phase);
+		if (phase !== "final" && !changed && steerIdle) return;
+		let waiting = false;
 		for (const request of readWorkerSteerRequests(deps.dir)) {
-			if (phase !== "final" && deps.signal?.aborted) return;
+			if (phase !== "final" && deps.signal?.aborted) {
+				steerIdle = false;
+				return;
+			}
 			const rootRequest = request.worker === deps.ownerId && deps.deliverRoot !== void 0;
 			if (phase === "boundary" && !rootRequest) continue;
 			if (!rootRequest && !isDirectChildNodeId(deps, request.worker)) continue;
@@ -546,7 +613,10 @@ function createSteerAcknowledger(deps) {
 				});
 				continue;
 			}
-			if (rootRequest && deps.deliverRootReady !== void 0 && !deps.deliverRootReady()) continue;
+			if (rootRequest && deps.deliverRootReady !== void 0 && !deps.deliverRootReady()) {
+				waiting = true;
+				continue;
+			}
 			if (!claimWorkerSteerDelivery(deps.dir, {
 				...base(request),
 				effect: "unknown",
@@ -595,17 +665,9 @@ function createSteerAcknowledger(deps) {
 				});
 			}
 		}
+		if (phase === "turn") steerIdle = !waiting;
 	} };
 }
-/**
-* The OPERATOR-facing sentence for a steer outcome, written into the durable acknowledgement file.
-*
-* Deliberately separate from `downMessageRefusalReasons`, which is the MANAGER-facing sentence: one
-* says what happened for someone reading the run afterwards, the other tells a model what to do
-* next, and merging them would make one audience read the other's copy. They must nonetheless cover
-* the SAME outcomes, so `tests/kernel/refusal-reasons.test.ts` holds both maps total over
-* `DownMessageDeliveryOutcome` — a new code cannot land in only one.
-*/
 function steerAcknowledgementDetail(outcome) {
 	switch (outcome.outcome) {
 		case "delivered": return "the owning manager delivered the steer to the exact live worker";
@@ -616,42 +678,32 @@ function steerAcknowledgementDetail(outcome) {
 		case "runtime-error": return "delivery outcome is unknown after a runtime error";
 	}
 }
-/**
-* The worker-cancel ACKNOWLEDGER — the runtime-side half of `run-layout`'s `cancelWorker`
-* contract. Router managers check between turns; native managers observe throughout their invocation.
-* Every manager with a `controlDir` mounts one;
-* OWNERSHIP keeps them from colliding: a request naming a node id is owned by the manager whose
-* own id is that node's parent, and a label/profile-name reference is owned by the `'run'`-scoped
-* (root) manager only — so exactly one acknowledger can ever apply one operation.
-*
-* Two-phase, honestly reported: `cancel_requested` is written the moment a live worker's abort is
-* issued (through the per-child abort chain the scope already owns, so siblings are untouched);
-* `cancelled` is written only when that worker's settlement is DELIVERED on the settle path with
-* a terminal `down`, and then the record names every subtree node id proven terminated. A worker
-* that already settled — or that settles `done` despite the abort — records `not_live`; a
-* reference matching nothing this manager owns stays pending (`cancelWorker` reports it
-* `unknown`). No path reports success for a missing worker.
-*
-* Expiry is run end, not a clock: `finish()` (after the final post-drain pass) writes `not_live`
-* for every owned request never applied and `unknown` for an issued abort whose settle the run
-* ended too soon to observe. A pending request can therefore never outlive its run and abort a
-* future spawn that happens to reuse a label.
-*
-* Idempotency is a lookup, in-process and across processes: an operation with a durable
-* acknowledgement is returned as-is and never re-applied.
-*/
 function createCancelAcknowledger(deps) {
 	const tracked = /* @__PURE__ */ new Map();
 	let runTracked;
 	const abortIssuedAt = /* @__PURE__ */ new Map();
 	const iso = () => new Date(deps.now()).toISOString();
+	const waiting = /* @__PURE__ */ new Map();
+	const reconciling = /* @__PURE__ */ new Map();
+	const regrowing = /* @__PURE__ */ new Set();
+	let inboxBytes;
+	const deaths = {
+		file: join(deps.dir, SPAWN_JOURNAL_FILE),
+		offset: 0,
+		partial: "",
+		at: /* @__PURE__ */ new Map()
+	};
+	const watch = (record) => {
+		if (record.effect === "cancel_requested") reconciling.set(record.operationId, record);
+		else reconciling.delete(record.operationId);
+		if (record.effect === "cancelled" && abortIssuedAt.has(record.operationId)) regrowing.add(record.operationId);
+		else regrowing.delete(record.operationId);
+	};
 	const write = (record) => {
 		writeWorkerCancellation(deps.dir, record);
 		tracked.set(record.operationId, record);
+		watch(record);
 	};
-	/** Whether this acknowledger owns `ref`. A node id deeper in this subtree belongs to the nested
-	*  manager that parents it; anything that is not a node id under this manager is a
-	*  label/profile-name reference, owned by the `'run'`-scoped manager alone. */
 	const owned = (ref) => {
 		if (isDirectChildNodeId(deps, ref)) return true;
 		if (deps.controlScope !== "run") return false;
@@ -694,15 +746,13 @@ function createCancelAcknowledger(deps) {
 			terminated: []
 		});
 	};
-	/** The proven-terminated set for one record: the worker plus every subtree id with a terminal
-	*  journal record at/after the abort was issued. Union with what the record already names, so
-	*  the set only ever grows (a late teardown journal adds; nothing removes). */
+	/** Grows only: the worker, the record's ids, and subtree deaths at or after the abort. */
 	const provenTerminated = (record, workerId) => {
 		const since = abortIssuedAt.get(record.operationId) ?? record.observedAt;
 		return [.../* @__PURE__ */ new Set([
 			...record.terminated,
 			workerId,
-			...terminatedDescendants(deps.dir, workerId, since)
+			...descendantsSince(deaths, workerId, since)
 		])].sort();
 	};
 	const reconcile = (record) => {
@@ -728,10 +778,6 @@ function createCancelAcknowledger(deps) {
 			detail: `worker '${workerId}' settled done despite the abort request; nothing was terminated`
 		});
 	};
-	/** Re-scan a `cancelled` record while the manager still turns: a descendant whose teardown
-	*  journals after the lead's settle joins the set on a later pass instead of being lost. Only
-	*  a grown set is re-written; the window needs the in-process abort instant, so a record a
-	*  PRIOR process closed stays as that process proved it. */
 	const regrow = (record) => {
 		const workerId = record.workerId;
 		if (workerId === void 0 || !abortIssuedAt.has(record.operationId)) return;
@@ -742,36 +788,49 @@ function createCancelAcknowledger(deps) {
 			terminated
 		});
 	};
-	/**
-	* The RUN-scoped request: seen once, `cancel_requested` written the moment the run's cascading
-	* abort is issued through the one controller the run already has. The `supervise()` settle path
-	* records what the run then actually did — this manager cannot observe its own tree's terminal
-	* state from inside `act`.
-	*
-	* Applied only at a TURN boundary, never on the final post-drain pass: by then the driver has
-	* finished and drained, so a root abort could only void work that is already delivered. A
-	* request that arrives that late expires in `finish()` instead — it terminated nothing.
-	*/
 	const passRun = () => {
 		if (deps.controlScope !== "run" || deps.abortRun === void 0) return;
 		if (runTracked !== void 0) return;
 		runTracked = applyRunCancellation(deps.dir, deps.abortRun, iso);
 	};
-	const pass = (phase) => {
-		if (phase === "turn") passRun();
+	const ingest = () => {
+		const file = workerCancelRequestsFile(deps.dir);
+		let size;
+		try {
+			size = statSync(file).size;
+		} catch {
+			size = null;
+		}
+		if (size === inboxBytes) return;
+		inboxBytes = size;
 		for (const request of readWorkerCancelRequests(deps.dir)) {
-			if (!owned(request.worker)) continue;
-			let record = tracked.get(request.operationId);
-			if (record === void 0) {
-				record = readWorkerCancellation(deps.dir, request.operationId);
-				if (record !== void 0) tracked.set(request.operationId, record);
-			}
-			if (record === void 0) {
-				if (phase === "turn") apply(request);
-				continue;
+			if (!owned(request.worker) || tracked.has(request.operationId) || waiting.has(request.operationId)) continue;
+			const record = readWorkerCancellation(deps.dir, request.operationId);
+			if (record === void 0) waiting.set(request.operationId, request);
+			else {
+				tracked.set(record.operationId, record);
+				watch(record);
 			}
-			if (record.effect === "cancel_requested") reconcile(record);
-			else if (record.effect === "cancelled") regrow(record);
+		}
+	};
+	const pass = (phase) => {
+		if (phase === "turn") passRun();
+		ingest();
+		const pending = [...reconciling.values()];
+		if (phase === "turn") for (const request of [...waiting.values()]) {
+			waiting.delete(request.operationId);
+			apply(request);
+			if (!tracked.has(request.operationId)) waiting.set(request.operationId, request);
+		}
+		const grew = indexDeaths(deaths);
+		for (const record of pending) {
+			const current = tracked.get(record.operationId);
+			if (current?.effect === "cancel_requested") reconcile(current);
+		}
+		if (!grew) return;
+		for (const id of [...regrowing]) {
+			const record = tracked.get(id);
+			if (record !== void 0) regrow(record);
 		}
 	};
 	return {
@@ -813,43 +872,6 @@ function createCancelAcknowledger(deps) {
 		}
 	};
 }
-/**
-* Subtree node ids with a terminal `down`/`cancelled` journal record at or after `sinceIso` —
-* the abort-issue instant (the acknowledger's own `observedAt` on the `cancel_requested` record,
-* runtime clock), never the client's `requestedAt` — read from the durable spawn journal beside
-* the run layout. The set is proven at acknowledgement time and is approximate about post-abort
-* causation: a descendant that died of its OWN cause after the abort was issued is
-* indistinguishable from the cascade and may be included; one whose teardown journals late joins
-* on a later acknowledger pass; a teardown journal still absent when the run ends is absent from
-* the set. Ids are hierarchical (`parent:sN`), so `${nodeId}:` prefixes exactly the subtree.
-* Tolerant of a missing or partially-written journal: evidence that cannot be read names fewer
-* nodes, never wrong ones.
-*/
-function terminatedDescendants(dir, nodeId, sinceIso) {
-	let raw;
-	try {
-		raw = readFileSync(join(dir, SPAWN_JOURNAL_FILE), "utf8");
-	} catch {
-		return [];
-	}
-	const prefix = `${nodeId}:`;
-	const ids = /* @__PURE__ */ new Set();
-	for (const line of raw.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			for (const event of spawnJournalRecordEvents(JSON.parse(trimmed))) {
-				if (event === void 0) continue;
-				if (!(event.kind === "settled" && event.status === "down" || event.kind === "cancelled")) continue;
-				if (typeof event.id !== "string" || !event.id.startsWith(prefix)) continue;
-				if (typeof event.at !== "string" || event.at < sinceIso) continue;
-				ids.add(event.id);
-			}
-		} catch {}
-	}
-	return [...ids].sort();
-}
-/** A direct child has exactly one generated spawn segment below its owner. */
 function isDirectChildNodeId(owner, ref) {
 	return ref.startsWith(`${owner.ownerId}:s`) && /^s\d+$/.test(ref.slice(owner.ownerId.length + 1));
 }
@@ -1866,15 +1888,13 @@ function mountGraphsTools({ opts, tools, admitSpawn }) {
 					error: "invalid-graph",
 					reason: prepared.reason
 				};
-				const profile = detachedFrozen(prepared.profile);
 				return admitSpawn({
-					profile,
+					profile: detachedFrozen(prepared.profile),
 					args: a,
 					task: deliverable,
 					key,
 					continuity: { continuity: "fresh" },
 					successorOf: void 0,
-					preflightProfile: () => opts.resolveSpawnProfile ? detachedFrozen(opts.resolveSpawnProfile(profile)) : profile,
 					resourcesFromPath: [],
 					defaultLabel: `graph:${prepared.root}`,
 					accepted: { graph: {
@@ -2153,6 +2173,10 @@ const projectEvent = (ev) => {
 		type: "tool-outcome",
 		...ev.outcome
 	};
+	if (ev.type === "tool-timing") return {
+		type: "tool-timing",
+		...ev.call
+	};
 	if (ev.type === "lead-message") return {
 		type: "lead-message",
 		...ev.message
@@ -3020,7 +3044,6 @@ async function spawnNode(state, marker, profile, task, key, continuity, traversa
 		key,
 		continuity,
 		successorOf: state.settledWorker.get(marker.node),
-		preflightProfile: () => state.opts.resolveSpawnProfile ? detachedFrozen(state.opts.resolveSpawnProfile(profile)) : profile,
 		resourcesFromPath: [],
 		defaultLabel: marker.node,
 		route: Object.freeze({ ...marker })
@@ -3680,14 +3703,21 @@ function resolveContinuity(state, requested, profileName, key) {
 * assignment, budget reservation, `Scope.spawn` — is synchronous and commits state.
 * Returns the refusal body, or `undefined` when the spawn may proceed.
 */
-async function preflightRefusal(state, input, label, task) {
+/** `spawn_worker`'s optional machine request, as the canonical resource request. */
+function spawnResources(raw) {
+	if (raw === void 0) return void 0;
+	const parsed = ResourceRequestSchema.omit({ providerOptions: true }).strict().safeParse(raw);
+	if (!parsed.success) throw new ValidationError(`spawn_worker resources: ${parsed.error.message}`);
+	return detachedFrozen(parsed.data);
+}
+async function preflightRefusal(state, effective, spawn) {
 	const { opts } = state;
 	if (!opts.preflightSpawn) return void 0;
-	const { key } = input;
-	const refusal = await opts.preflightSpawn(input.preflightProfile(), {
-		label,
+	const { key, resources, ...rest } = spawn;
+	const refusal = await opts.preflightSpawn(effective, {
+		...rest,
 		...key !== void 0 ? { key } : {},
-		task
+		...resources !== void 0 ? { resources } : {}
 	});
 	if (!refusal) return void 0;
 	state.preflightCounts[refusal.cause] += 1;
@@ -3706,7 +3736,14 @@ async function admitSpawn(state, input) {
 	const a = input.args;
 	const task = detachedFrozen(input.task);
 	const label = typeof a.label === "string" ? a.label : input.defaultLabel;
-	const refused = await preflightRefusal(state, input, label, task);
+	const effective = opts.resolveSpawnProfile ? detachedFrozen(opts.resolveSpawnProfile(profile)) : profile;
+	const resources = spawnResources(a.resources);
+	const refused = await preflightRefusal(state, effective, {
+		label,
+		task,
+		key,
+		resources
+	});
 	if (refused !== void 0) return refused;
 	const budget = Object.freeze(a.budget === void 0 ? opts.perWorker : mergeBudget(opts.perWorker, a.budget));
 	const assignmentId = key !== void 0 ? `key:${key}` : `ordinal:${state.unkeyedAssignment.next++}`;
@@ -3718,6 +3755,7 @@ async function admitSpawn(state, input) {
 		task,
 		label,
 		...key !== void 0 ? { key } : {},
+		...resources !== void 0 ? { resources } : {},
 		continuity: continuity.continuity,
 		...continuity.continuity === "resume" ? { resume: continuity.resume } : {},
 		...successorOf !== void 0 ? { successorOf } : {},
@@ -3725,7 +3763,7 @@ async function admitSpawn(state, input) {
 		...input.map !== void 0 ? { map: input.map } : {},
 		...input.route !== void 0 ? { route: input.route } : {}
 	});
-	const res = opts.scope.spawn(() => opts.makeWorkerAgent(profile, context), task, {
+	const res = opts.scope.spawn(() => opts.makeWorkerAgent(effective, context), task, {
 		budget,
 		label,
 		assignmentId,
@@ -4368,7 +4406,7 @@ function spawnWorkerTool(ctx) {
 	const { profileTable } = ctx;
 	return {
 		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 sub-task more or less than the default — it merges over the per-worker default; the conserved pool is still the hard fence. Each worker reserves only the channels capped by the pool. workerSlots sets concurrency. A funded worker waits with `status: \"queued\"` when every slot is busy and starts when one frees. A new worker whose budget cannot fit is refused immediately. Wait for settlements or request a smaller allocation before trying again. End your turn to be woken with results. 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 keyed worker that settled with a `budgetStop` keeps its session for a while: spawn the same key with a larger `budget` and a new worker continues that same session where it stopped (`resumed: \"continued\"`, `priorWorkerId`), or cancel_worker the stopped worker to release it. A key whose prior attempt failed (`down`) spawns fresh and says so (`resumed: \"retried\"`), and a key the process died with IN FLIGHT retries under the same key when the executor provably died with the process (an inline worker — the same `resumed: \"retried\"`, naming the interruption). A key with no terminal receipt whose execution may still exist elsewhere (sandbox, CLI bridge, router) 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 start at once (`null` = no slot bound), and `queued`: how many of your workers wait for a slot. 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."),
+		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 sub-task more or less than the default — it merges over the per-worker default; the conserved pool is still the hard fence. Each worker reserves only the channels capped by the pool. workerSlots sets concurrency. A funded worker waits with `status: \"queued\"` when every slot is busy and starts when one frees. A new worker whose budget cannot fit is refused immediately. Wait for settlements or request a smaller allocation before trying again. End your turn to be woken with results. 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 keyed worker that settled with a `budgetStop` keeps its session for a while: spawn the same key with a larger `budget` and a new worker continues that same session where it stopped (`resumed: \"continued\"`, `priorWorkerId`), or cancel_worker the stopped worker to release it. A key whose prior attempt failed (`down`) spawns fresh and says so (`resumed: \"retried\"`), and a key the process died with IN FLIGHT retries under the same key when the executor provably died with the process (an inline worker — the same `resumed: \"retried\"`, naming the interruption). A key with no terminal receipt whose execution may still exist elsewhere (sandbox, CLI bridge, router) 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 start at once (`null` = no slot bound), and `queued`: how many of your workers wait for a slot. Parallel workers finish the run sooner than one at a time. An authored profile must be fully executable before it spawns: `harness`, `model.provider`, a concrete `model.default`, and no legacy `systemPrompt` — one refusal names every field still missing." + (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: {
@@ -4389,9 +4427,29 @@ function spawnWorkerTool(ctx) {
 				},
 				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\"` — end your turn until it settles). Put what the successor needs from its predecessor in `task`."
+					description: "The workerId of a worker you spawned that this new worker revises or replaces — for example one that failed, stalled, or finished with a weak result, restarted with a changed profile or task. The predecessor may still be live; cancel_worker it if the successor supersedes it. The run record names the predecessor on the new worker. Refused for an id you did not spawn (`error: \"successor-unknown\"`). Put what the successor needs from its predecessor in `task`."
 				},
-				budget: spawnBudgetArg
+				budget: spawnBudgetArg,
+				resources: {
+					type: "object",
+					description: "Optional machine for this worker: `cpu`, `memoryMb`, `diskMb`, `gpu`. Omit for the run's default. Refused, naming the ceiling, above the backend's `maxWorkerResources`.",
+					properties: {
+						cpu: {
+							type: "number",
+							exclusiveMinimum: 0
+						},
+						memoryMb: {
+							type: "number",
+							exclusiveMinimum: 0
+						},
+						diskMb: {
+							type: "number",
+							exclusiveMinimum: 0
+						},
+						gpu: { type: "string" }
+					},
+					additionalProperties: false
+				}
 			},
 			required: ["profile", "task"]
 		},
@@ -4446,15 +4504,9 @@ function successorRefusal({ opts, spawn, workers }, successorOf) {
 		live: workers.liveWorkerCount(),
 		freeSlots: workers.freeWorkerSlots()
 	};
-	if (isLiveNodeStatus(predecessor.status)) return {
-		error: "successor-live",
-		reason: `worker '${successorOf}' has not settled — end your turn until it does, then spawn its successor (steer_agent redirects a live worker instead)`,
-		live: workers.liveWorkerCount(),
-		freeSlots: workers.freeWorkerSlots()
-	};
 }
 async function spawnWorkerHandler(ctx, raw) {
-	const { opts, spawn, workers } = ctx;
+	const { spawn, workers } = ctx;
 	const a = obj(raw);
 	const key = a.key === void 0 ? void 0 : str(a.key, "key");
 	const resolvedProfile = await resolveSpawnedProfile(ctx, a.profile);
@@ -4480,7 +4532,6 @@ async function spawnWorkerHandler(ctx, raw) {
 		key,
 		continuity,
 		successorOf,
-		preflightProfile: () => opts.resolveSpawnProfile ? detachedFrozen(opts.resolveSpawnProfile(profile)) : profile,
 		resourcesFromPath: resolved,
 		defaultLabel: typeof profile.name === "string" && profile.name.length > 0 ? profile.name : "worker"
 	});
@@ -4926,7 +4977,54 @@ function assembleTools(parts) {
 		analystRunContext: analysis.analystRunContext,
 		defineAnalyst: analysis.defineAnalyst
 	});
-	return tools;
+	return tools.map((tool) => timeCoordinationTool(bus, tool));
+}
+/** Record handler duration for every coordination tool call without changing its result. */
+function timeCoordinationTool(bus, tool) {
+	return {
+		...tool,
+		handler: async (raw) => {
+			const receivedAt = Date.now();
+			try {
+				const value = await tool.handler(raw);
+				await recordToolTiming(bus, tool.name, receivedAt, true, value);
+				return value;
+			} catch (error) {
+				await recordToolTiming(bus, tool.name, receivedAt, false, error);
+				throw error;
+			}
+		}
+	};
+}
+async function recordToolTiming(bus, tool, receivedAt, ok, value) {
+	try {
+		await bus.publish({
+			type: "tool-timing",
+			call: {
+				tool,
+				receivedAt,
+				elapsedMs: Math.max(0, Date.now() - receivedAt),
+				responseBytes: responseUtf8Bytes(ok ? value : errorText(value)),
+				ok
+			}
+		}, { queue: false });
+	} catch (error) {
+		console.error("Runtime could not record coordination tool timing", {
+			tool,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+function responseUtf8Bytes(value) {
+	if (typeof value === "string") return Buffer.byteLength(value);
+	try {
+		return Buffer.byteLength(JSON.stringify(value) ?? "null");
+	} catch {
+		return Buffer.byteLength(String(value));
+	}
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
 }
 function managerSurface(parts, tools) {
 	const { opts, bus, state, ledger, questionLedger, spawnAdmission, analysis, settlements, messages, workers, waiting, intake, journal, peerMail, ackEnv, ready } = parts;
@@ -5135,4 +5233,4 @@ function createResumeReplay({ opts, bus, ledger, analysis, projectSettled }) {
 }
 export { downMessageRefusalReasons as a, createSteerAcknowledger as c, coordinationVerbNames as d, createFileRunContext as f, watchTrace as i, budgetOverspendText as l, withRunContext as m, createCoordinationToolsForManager as n, createEventBus as o, createInMemoryRunContext as p, defaultToolDetectors as r, createCancelAcknowledger as s, createCoordinationTools as t, normalizeAnalyzeOnSettle as u };
 
-//# sourceMappingURL=coordination-manager-D9z7To7p.js.map
+//# sourceMappingURL=coordination-manager-sa_PkISw.js.map