@tangle-network/agent-runtime 0.219.0 → 0.220.1

package/dist/{coordination-driver-CvinSUI-.js → coordination-driver-BxGh-Tnj.js}

@@ -1,385 +1,355 @@
-import { An as unmeteredSpend, Fn as withBudgetResources, Ht as isLiveNodeStatus, Jr as isNoEntError, Nn as addResourceSpend, Nt as createInbox, Qn as resolveRedactor, Rt as createPeerMailbox, Ut as isTerminalNodeStatus, W as freeSlots, Xr as prepareJsonlAppend, Yr as parseCommittedJsonLines, Zr as writeAllBytes, a as pickBestDelivered, ct as InMemoryResultBlobStore, d as withDriverExecutor, et as createExecutorRegistry, g as meterRuntimeOwnedProviderAttempt, ln as runBrainLoop, lt as InMemorySpawnJournal, o as runFinalizer, oi as providerAttemptEvidence, ot as FileResultBlobStore, r as bestDelivered, s as runTree, st as FileSpawnJournal, vi as detachedFrozen, vt as parseWorkerToolTraceArtifact, wn as promptCacheTokenClasses, xt as assertValidBudget, yn as chargedTokens, yt as workerTraceAnalysisStore } from "./supervisor-WRrw0nlk.js";
+import { $r as parseCommittedJsonLines, Cn as chargedTokens, Ct as workerTraceAnalysisStore, Ht as createPeerMailbox, J as freeSlots, Kt as isLiveNodeStatus, Ln as addResourceSpend, Lt as createInbox, On as promptCacheTokenClasses, Pn as unmeteredSpend, Qr as isNoEntError, Si as detachedFrozen, St as parseWorkerToolTraceArtifact, Tt as assertValidBudget, a as pickBestDelivered, b as meterRuntimeOwnedProviderAttempt, dt as FileSpawnJournal, ei as prepareJsonlAppend, ft as InMemoryResultBlobStore, h as withDriverExecutor, it as createExecutorRegistry, nr as resolveRedactor, o as runFinalizer, pn as runBrainLoop, pt as InMemorySpawnJournal, qt as isTerminalNodeStatus, r as bestDelivered, s as runTree, ti as writeAllBytes, ui as providerAttemptEvidence, ut as FileResultBlobStore, zn as withBudgetResources } from "./supervisor-n8DDNGli.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-hZREkcfu.js";
 import { agentProfileSchema, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { argHash, errorStreakDetector, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, watch } from "node:fs";
-import { join } from "node:path";
-//#region src/runtime/supervise/run-cancellation.ts
-/** Apply a durable request through the run's existing abort controller. */
-function applyRunCancellation(dir, abortRun, now, path = "turn-boundary") {
-	const request = readRunCancelRequest(dir);
-	if (request === void 0) return void 0;
-	const prior = readRunCancellation(dir, request.operationId);
-	if (prior !== void 0) return prior;
-	abortRun(request.reason ?? "run cancel requested", request);
-	const observedAt = now();
-	const appliedAfterMs = Math.max(0, Date.parse(observedAt) - Date.parse(request.at));
-	const record = {
-		operationId: request.operationId,
-		effect: "cancel_requested",
-		path,
-		appliedAfterMs,
-		...request.deadlineMs === void 0 ? {} : { deadlineExceeded: appliedAfterMs > request.deadlineMs },
-		requestedAt: request.at,
-		observedAt,
-		...request.reason === void 0 ? {} : { reason: request.reason },
-		detail: "root abort issued to the whole run; termination not yet proven"
-	};
-	writeRunCancellation(dir, record);
-	return record;
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { open, realpath, stat } from "node:fs/promises";
+//#region src/runtime/supervise/detector-monitor.ts
+/**
+*
+* The ONLINE analyst: watch a `TraceSource` and fold each tool span through agent-eval's published
+* streaming detector kernel (`repeatedActionDetector`/`errorStreakDetector` — the SAME kernel the
+* control loop folds), firing `onSignal` the moment a worker loops or error-storms. Substrate-
+* agnostic: it consumes spans from any source (owned router/bridge loop OR a sandbox box session),
+* never the raw tool seam. Detection logic + the failure taxonomy live in agent-eval; not reimplemented.
+*
+* @experimental
+*/
+/** The default online panel for a tool-call pipe: a worker repeating the same call, or hammering
+*  consecutive errors. (No-progress needs a domain progress-probe, so it is opt-in, not default.)
+*
+*  Coverage note: `repeated-action` works for EVERY harness (it needs only tool name + args, which
+*  every adapter provides). `error-streak` needs per-call status — opencode carries it inline
+*  (`state.status`, VALIDATED live), but claude-code/codex tool-call parts do NOT (their errors live
+*  in separate result blocks not yet decoded), so error-streak is silent for those until result-block
+*  decoding is added + live-validated. It is in the panel because it is correct where status exists. */
+function defaultToolDetectors() {
+	return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
 }
-/** External drivers may remain silent indefinitely, so turn boundaries cannot observe control. */
-function watchRunCancellation(dir, abortRun) {
-	mkdirSync(workerCancellationsDir(dir), { recursive: true });
-	let active = true;
-	let failure;
-	const check = (path = "observer") => {
-		if (failure !== void 0) throw failure;
-		if (active) applyRunCancellation(dir, abortRun, () => (/* @__PURE__ */ new Date()).toISOString(), path);
-	};
-	const fail = (error) => {
-		if (!active) return;
-		failure = error;
-		abortRun(`durable run cancellation observer failed: ${String(error)}`);
-	};
-	const watcher = watch(workerCancellationsDir(dir), (_event, filename) => {
-		if (!active || filename !== null && filename !== "run.request.json") return;
+/** Subscribe to a `TraceSource` and run the streaming detectors over its live spans. Returns an
+*  unsubscribe. A defensive `argHash` failure (circular args) never throws out of the side-channel. */
+function watchTrace(source, opts = {}) {
+	const detectors = opts.detectors ?? defaultToolDetectors();
+	return source.onSpan((span) => {
+		let fingerprint;
 		try {
-			check();
-		} catch (error) {
-			fail(error);
+			fingerprint = `${span.toolName}|${argHash(span.args)}`;
+		} catch {
+			fingerprint = `${span.toolName}|<unhashable>`;
 		}
+		const signals = observeAll(detectors, {
+			actionFingerprint: fingerprint,
+			...span.status ? { status: span.status } : {},
+			label: span.toolName
+		});
+		for (const s of signals) opts.onSignal?.(s, span);
 	});
-	watcher.on("error", fail);
-	const fallback = setInterval(() => {
-		try {
-			check("fallback");
-		} catch (error) {
-			fail(error);
+}
+//#endregion
+//#region src/runtime/supervise/event-bus.ts
+/** Create the child→parent coordination bus: one typed pipe for settled outputs, questions, and analyst findings, with a priority-ordered pull queue and a pass-through subscribe lane.
+* @experimental In-process queue; durability is a transport swap that does not exist yet. */
+function createEventBus(now = Date.now) {
+	const queue = [];
+	const log = [];
+	const subscribers = [];
+	const byKind = {};
+	const staged = /* @__PURE__ */ new WeakMap();
+	let seq = 0;
+	let published = 0;
+	let pulled = 0;
+	const matches = (r, kinds) => !kinds || kinds.includes(r.event.type);
+	const bestIndex = (kinds) => {
+		let best = -1;
+		let bestPriority = Number.NEGATIVE_INFINITY;
+		for (let i = 0; i < queue.length; i++) {
+			const r = queue[i];
+			if (!r || !matches(r, kinds)) continue;
+			if (r.priority > bestPriority) {
+				best = i;
+				bestPriority = r.priority;
+			}
 		}
-	}, 100);
-	fallback.unref();
+		return best;
+	};
 	return {
-		check,
-		close() {
-			active = false;
-			watcher.close();
-			clearInterval(fallback);
+		async publish(event, opts) {
+			const record = staged.get(event) ?? {
+				seq: seq++,
+				at: now(),
+				priority: opts?.priority ?? 0,
+				event
+			};
+			staged.set(event, record);
+			for (const handler of subscribers) await handler(record);
+			staged.delete(event);
+			if (opts?.queue !== false) queue.push(record);
+			log.push(record);
+			published += 1;
+			byKind[event.type] = (byKind[event.type] ?? 0) + 1;
+			return record;
+		},
+		pull(kinds) {
+			const i = bestIndex(kinds);
+			if (i < 0) return void 0;
+			pulled++;
+			return queue.splice(i, 1)[0]?.event;
+		},
+		subscribe(handler) {
+			subscribers.push(handler);
+			return () => {
+				const i = subscribers.indexOf(handler);
+				if (i >= 0) subscribers.splice(i, 1);
+			};
+		},
+		pending(kinds) {
+			return kinds ? queue.filter((r) => matches(r, kinds)).length : queue.length;
+		},
+		history() {
+			return log;
+		},
+		stats() {
+			return {
+				published,
+				pulled,
+				byKind: { ...byKind }
+			};
 		}
 	};
 }
 //#endregion
-//#region src/runtime/supervise/coordination-log.ts
+//#region src/mcp/tools/spawn-resource-paths.ts
 /**
-* Durable side-log for coordination evidence the spawn journal does not own: questions, analyst
-* findings, answer decisions, authorized continuation receipts, delivery-attempt markers, and
-* delivery outcomes. A durable run
-* (`supervise({ runDir })`) appends them as they publish and loads them on resume, so a restarted
-* coordinator retains the exact evidence produced by prior processes.
+* Inline resources a manager hands a child by PATH instead of by content.
 *
-* Answer down-events also fold status on load: a question answered before the crash reloads as
-* `answered`, not as a re-blocking `open`. Settled events are skipped (the spawn journal is their
-* ledger). A receipt followed by an attempt but no outcome proves the process died in the delivery
-* window; that outcome remains unknown and no prior instruction is auto-delivered.
+* The canonical profile schema knows two resource kinds, `inline` (a content string) and `github`.
+* A manager that wants a child to receive a data file therefore had one way to do it: emit the
+* bytes inside its own `spawn` tool call. That is a transcription by a language model, and it does
+* not survive size. Measured 2026-09-12 (discovery-lab `mech-interp-foundations-glm2-b-20260912b`):
+* a 29,144-character base64 payload on the manager's disk reached three children as 15,928
+* characters with 11 substitutions, and a fourth child received the literal placeholder the
+* manager meant to replace. Seven blind-check attempts across two runs delivered no data.
 *
-* JSONL, one fsynced record per event, keyed by `runId` — several runs may share one log file
-* exactly as they share one spawn-journal file.
+* `{ kind: 'inline', name, path }` lets the coordination server be the transport: it reads the
+* file under the manager's workspace root, fills `content`, and the profile that reaches the
+* schema, the journal, and the provider is an ordinary inline resource. Nothing downstream
+* changes; the model's output stops carrying the bytes.
 *
-* @experimental
+* Fail-closed rules, each with the reason a manager needs to fix its call:
+*  - no root configured → refused (a nested manager in a remote sandbox has no host directory
+*    the server may read for it)
+*  - absolute path, `..` escape, or a symlink that resolves outside the root → refused; the
+*    workspace root is the only directory a manager may hand out
+*  - not a regular file → refused
+*  - over {@link SPAWN_RESOURCE_PATH_MAX_BYTES} → refused naming the bound
+*  - bytes that are not valid UTF-8 → refused; `content` is a string, so binary data is encoded
+*    (base64) by the manager first, exactly as it would be for a content resource
 */
-/** Persist prior context plus exact continuation authorization, attempt, and result evidence.
-* Settlements have their own journal. */
-function persisted(event) {
-	return event.type !== "settled";
+const SPAWN_RESOURCE_PATH_MAX_BYTES = 4 * 1024 * 1024;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/** FS-backed `CoordinationLog`: append-only JSONL, fsynced per record. */
-var FileCoordinationLog = class {
-	path;
-	appendTail = Promise.resolve();
-	constructor(path) {
-		this.path = path;
+/** An inline ref that names a path and carries no content. Anything else is left untouched so the
+*  canonical schema keeps its verdict on it. */
+function pathInlineRef(value) {
+	if (!isRecord(value)) return void 0;
+	if (value.kind !== "inline" || value.content !== void 0) return void 0;
+	if (typeof value.path !== "string" || typeof value.name !== "string") return void 0;
+	return {
+		kind: "inline",
+		name: value.name,
+		path: value.path
+	};
+}
+async function readUnderRoot(root, requested) {
+	if (requested.length === 0) return {
+		ok: false,
+		reason: "path is empty"
+	};
+	if (isAbsolute(requested)) return {
+		ok: false,
+		reason: `path must be relative to the workspace root, not absolute (${requested})`
+	};
+	const rootReal = await realpath(root).catch(() => void 0);
+	if (rootReal === void 0) return {
+		ok: false,
+		reason: `workspace root ${root} does not exist`
+	};
+	const candidate = resolve(rootReal, requested);
+	if (!inside(rootReal, candidate)) return {
+		ok: false,
+		reason: `path ${requested} leaves the workspace root`
+	};
+	let handle;
+	try {
+		handle = await open(candidate, "r");
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `path ${requested}: ${describe(error)}`
+		};
 	}
-	async append(runId, record, ownerId) {
-		if (!persisted(record.event)) return;
-		const append = this.appendTail.then(() => this.appendRecord(runId, record, ownerId));
-		this.appendTail = append.catch(() => void 0);
-		return append;
+	try {
+		const info = await handle.stat();
+		if (!info.isFile()) return {
+			ok: false,
+			reason: `path ${requested} is not a regular file`
+		};
+		const real = await realpath(candidate).catch(() => void 0);
+		if (real === void 0 || !inside(rootReal, real)) return {
+			ok: false,
+			reason: `path ${requested} resolves outside the workspace root`
+		};
+		const named = await stat(real).catch(() => void 0);
+		if (named === void 0 || named.dev !== info.dev || named.ino !== info.ino) return {
+			ok: false,
+			reason: `path ${requested} changed while it was being read; retry the spawn`
+		};
+		if (info.size > 4194304) return {
+			ok: false,
+			reason: `path ${requested} is ${info.size} bytes; an inline resource is at most ${SPAWN_RESOURCE_PATH_MAX_BYTES} bytes`
+		};
+		const bytes = await handle.readFile();
+		if (bytes.length > 4194304) return {
+			ok: false,
+			reason: `path ${requested} is ${bytes.length} bytes; an inline resource is at most ${SPAWN_RESOURCE_PATH_MAX_BYTES} bytes`
+		};
+		const content = bytes.toString("utf8");
+		if (!Buffer.from(content, "utf8").equals(bytes)) return {
+			ok: false,
+			reason: `path ${requested} is not valid UTF-8; encode binary data (base64) before handing it to a child`
+		};
+		return {
+			ok: true,
+			content,
+			byteLength: bytes.length,
+			sha256: createHash("sha256").update(bytes).digest("hex")
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `path ${requested}: ${describe(error)}`
+		};
+	} finally {
+		await handle.close().catch(() => void 0);
 	}
-	async appendRecord(runId, busRecord, ownerId) {
-		const fs = await import("node:fs/promises");
-		const path = await import("node:path");
-		await fs.mkdir(path.dirname(this.path), { recursive: true });
-		const record = {
-			runId,
-			...ownerId !== void 0 ? { ownerId } : {},
-			...busRecord
+}
+/** `target` is `rootReal` itself or strictly below it; both must already be absolute. */
+function inside(rootReal, target) {
+	const rel = relative(rootReal, target);
+	return rel !== "" && !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+function describe(error) {
+	const code = error?.code;
+	if (code === "ENOENT") return "does not exist under the workspace root";
+	if (code === "EACCES" || code === "EPERM") return "is not readable by the runtime process";
+	if (code === "EISDIR") return "is not a regular file";
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Replace every `{ kind: 'inline', name, path }` under `profile.resources` with the inline
+* resource its bytes make. Returns the profile unchanged (same reference) when nothing names a
+* path, so callers pay nothing on the common case.
+*/
+async function resolveSpawnResourcePaths(profile, root) {
+	if (!isRecord(profile) || !isRecord(profile.resources)) return {
+		ok: true,
+		profile,
+		resolved: []
+	};
+	const resources = profile.resources;
+	const resolved = [];
+	let touched = false;
+	const next = { ...resources };
+	const substitute = async (at, ref) => {
+		if (root === void 0) return { error: "this manager has no workspace root the coordination server may read, so a resource by path cannot be resolved; pass content, or a github resource" };
+		const read = await readUnderRoot(root, ref.path);
+		if (!read.ok) return { error: read.reason };
+		resolved.push({
+			at,
+			path: ref.path,
+			byteLength: read.byteLength,
+			sha256: read.sha256
+		});
+		touched = true;
+		return {
+			kind: "inline",
+			name: ref.name,
+			content: read.content
 		};
-		const needsSeparator = await prepareJsonlAppend(this.path);
-		const fh = await fs.open(this.path, "a");
-		try {
-			await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
-			await fh.sync();
-		} finally {
-			await fh.close();
+	};
+	for (const list of [
+		"tools",
+		"skills",
+		"agents"
+	]) {
+		const entries = resources[list];
+		if (!Array.isArray(entries)) continue;
+		const out = [];
+		for (const [index, entry] of entries.entries()) {
+			const ref = pathInlineRef(entry);
+			if (ref === void 0) {
+				out.push(entry);
+				continue;
+			}
+			const at = `${list}[${index}]`;
+			const replaced = await substitute(at, ref);
+			if ("error" in replaced) return {
+				ok: false,
+				at,
+				reason: replaced.error
+			};
+			out.push(replaced);
 		}
+		next[list] = out;
 	}
-	async load(runId, ownerId) {
-		const fs = await import("node:fs/promises");
-		let text;
-		try {
-			text = await fs.readFile(this.path, "utf8");
-		} catch (err) {
-			if (isNoEntError(err)) return emptyPriorCoordination(ownerId);
-			throw err;
+	if (Array.isArray(resources.files)) {
+		const out = [];
+		for (const [index, mount] of resources.files.entries()) {
+			const ref = isRecord(mount) ? pathInlineRef(mount.resource) : void 0;
+			if (ref === void 0 || !isRecord(mount)) {
+				out.push(mount);
+				continue;
+			}
+			const at = `files[${index}].resource`;
+			const replaced = await substitute(at, ref);
+			if ("error" in replaced) return {
+				ok: false,
+				at,
+				reason: replaced.error
+			};
+			out.push({
+				...mount,
+				resource: replaced
+			});
 		}
-		const byId = /* @__PURE__ */ new Map();
-		const findings = [];
-		const escalations = [];
-		const analystDefinitions = [];
-		const continuations = [];
-		const deliveryEvidence = [];
-		const mail = [];
-		const records = [];
-		let legacySeq = 0;
-		for (const stored of parseCommittedJsonLines(text, this.path)) {
-			if (stored.runId !== runId) continue;
-			if (ownerId !== void 0 && stored.ownerId !== ownerId) continue;
-			const record = "seq" in stored ? {
-				seq: stored.seq,
-				at: stored.at,
-				priority: stored.priority,
-				event: stored.event
-			} : {
-				seq: legacySeq++,
-				at: Date.parse(stored.at),
-				priority: 0,
-				event: stored.event
-			};
-			records.push(record);
-			const ev = record.event;
-			if (ev.type === "delivery-attempt" || ev.type === "steer" || ev.type === "answer") deliveryEvidence.push(ev);
-			if (ev.type === "question") byId.set(ev.question.id, ev.question);
-			else if (ev.type === "finding") findings.push(ev.finding);
-			else if (ev.type === "answer") {
-				const prior = byId.get(ev.questionId);
-				if (prior && ev.down.delivered) byId.set(ev.questionId, {
-					...prior,
-					status: "answered",
-					decision: {
-						kind: "answer",
-						answer: ev.down.instruction,
-						by: "prior-run"
-					}
-				});
-			} else if (ev.type === "instruction") continuations.push(ev.instruction);
-			else if (ev.type === "mail") mail.push(ev.mail);
-			else if (ev.type === "escalation") escalations.push(ev.escalation);
-			else if (ev.type === "analyst-defined") analystDefinitions.push(ev.analyst);
-		}
-		return {
-			...ownerId !== void 0 ? { ownerId } : {},
-			questions: [...byId.values()],
-			findings,
-			escalations,
-			analystDefinitions,
-			continuations,
-			deliveryEvidence,
-			mail,
-			records
+		next.files = out;
+	}
+	const instructions = pathInlineRef(resources.instructions);
+	if (instructions !== void 0) {
+		const replaced = await substitute("instructions", instructions);
+		if ("error" in replaced) return {
+			ok: false,
+			at: "instructions",
+			reason: replaced.error
 		};
+		next.instructions = replaced;
 	}
-};
-function emptyPriorCoordination(ownerId) {
-	return {
-		...ownerId !== void 0 ? { ownerId } : {},
-		questions: [],
-		findings: [],
-		escalations: [],
-		analystDefinitions: [],
-		continuations: [],
-		deliveryEvidence: [],
-		mail: [],
-		records: []
-	};
-}
-//#endregion
-//#region src/runtime/supervise/run-context.ts
-/**
-*
-* `createInMemoryRunContext` — the one-call bundle of the in-memory stores a
-* `createSupervisor().run(root, task, opts)` needs: a fresh `InMemorySpawnJournal`
-* (the event-sourced spawn log), a fresh `InMemoryResultBlobStore` (the
-* content-addressed `outRef` payload store the driver's `observe`/`finalize` reads
-* settled outputs through), and a fresh `createExecutorRegistry()` (the open
-* `AgentSpec → Executor` resolver).
-*
-* It exists to kill the boilerplate every offline/local supervised run repeats by
-* hand — three constructors threaded into `SupervisorOpts` — and to single-source the
-* ONE wiring invariant that is easy to get wrong: when the root is the recursive
-* `driverAgent` LLM-driver brain AND it may spawn nested managed children, the registry MUST be
-* wrapped with `withDriverExecutor` so a child constructed by `driverChild` resolves to the
-* nested-scope executor — and that SAME blob
-* store MUST be the one passed to `driverAgent({ blobs })`, or the driver
-* reads from a different store than the scope writes to. Pass `{ withDriver: true }`
-* and reuse the returned `blobs` for both.
-*
-* The spread shape matches `SupervisorOpts` exactly, so the call site reads:
-*   const run = createInMemoryRunContext()
-*   await createSupervisor().run(root, task, { budget, runId, ...run })
-*
-* @experimental
-*/
-/**
-* Build a fresh in-memory run context. Every call returns NEW stores (no shared global
-* state between runs), so two runs never cross-contaminate their journals/blobs.
-*/
-function createInMemoryRunContext(opts = {}) {
-	const base = createExecutorRegistry();
-	return {
-		journal: new InMemorySpawnJournal(),
-		blobs: new InMemoryResultBlobStore(),
-		executors: opts.withDriver ? withDriverExecutor(base) : base
-	};
-}
-/**
-* Build a DURABLE run context: the spawn journal and the result blobs are file-backed (fsynced
-* per append/write) under `dir`, and the context carries `resume: true` so spreading it into
-* `SupervisorOpts` makes the supervisor `loadTree`-first. A run that dies mid-flight therefore
-* resumes when it is re-run with the SAME `runId` and the SAME `dir`: the committed children come
-* back on `Scope.resume` (rehydrated by `replaySpawnTree`) instead of being re-executed.
-*
-* Layout: `${dir}/spawn-journal.jsonl` (one JSONL record per event), `${dir}/blobs/` (one
-* content-addressed JSON file per settled result), and `${dir}/coordination-log.jsonl`
-* (questions, findings, answer decisions, and authorized continuation receipts retained as
-* evidence). The directory is created on first write.
-*
-* Opt-in by construction — `createInMemoryRunContext()` is unchanged and stays the default, so no
-* existing consumer writes to disk or resumes unless it asks for this.
-*/
-function createFileRunContext(dir, opts = {}) {
-	const base = createExecutorRegistry();
-	return {
-		journal: new FileSpawnJournal(`${dir}/spawn-journal.jsonl`),
-		blobs: new FileResultBlobStore(`${dir}/blobs`),
-		executors: opts.withDriver ? withDriverExecutor(base) : base,
-		resume: true,
-		coordinationLog: new FileCoordinationLog(`${dir}/coordination-log.jsonl`)
-	};
-}
-//#endregion
-//#region src/runtime/supervise/detector-monitor.ts
-/**
-*
-* The ONLINE analyst: watch a `TraceSource` and fold each tool span through agent-eval's published
-* streaming detector kernel (`repeatedActionDetector`/`errorStreakDetector` — the SAME kernel the
-* control loop folds), firing `onSignal` the moment a worker loops or error-storms. Substrate-
-* agnostic: it consumes spans from any source (owned router/bridge loop OR a sandbox box session),
-* never the raw tool seam. Detection logic + the failure taxonomy live in agent-eval; not reimplemented.
-*
-* @experimental
-*/
-/** The default online panel for a tool-call pipe: a worker repeating the same call, or hammering
-*  consecutive errors. (No-progress needs a domain progress-probe, so it is opt-in, not default.)
-*
-*  Coverage note: `repeated-action` works for EVERY harness (it needs only tool name + args, which
-*  every adapter provides). `error-streak` needs per-call status — opencode carries it inline
-*  (`state.status`, VALIDATED live), but claude-code/codex tool-call parts do NOT (their errors live
-*  in separate result blocks not yet decoded), so error-streak is silent for those until result-block
-*  decoding is added + live-validated. It is in the panel because it is correct where status exists. */
-function defaultToolDetectors() {
-	return [repeatedActionDetector({ maxRepeated: 3 }), errorStreakDetector({ maxErrors: 3 })];
-}
-/** Subscribe to a `TraceSource` and run the streaming detectors over its live spans. Returns an
-*  unsubscribe. A defensive `argHash` failure (circular args) never throws out of the side-channel. */
-function watchTrace(source, opts = {}) {
-	const detectors = opts.detectors ?? defaultToolDetectors();
-	return source.onSpan((span) => {
-		let fingerprint;
-		try {
-			fingerprint = `${span.toolName}|${argHash(span.args)}`;
-		} catch {
-			fingerprint = `${span.toolName}|<unhashable>`;
-		}
-		const signals = observeAll(detectors, {
-			actionFingerprint: fingerprint,
-			...span.status ? { status: span.status } : {},
-			label: span.toolName
-		});
-		for (const s of signals) opts.onSignal?.(s, span);
-	});
-}
-//#endregion
-//#region src/runtime/supervise/event-bus.ts
-/** Create the child→parent coordination bus: one typed pipe for settled outputs, questions, and analyst findings, with a priority-ordered pull queue and a pass-through subscribe lane.
-* @experimental In-process queue; durability is a transport swap that does not exist yet. */
-function createEventBus(now = Date.now) {
-	const queue = [];
-	const log = [];
-	const subscribers = [];
-	const byKind = {};
-	const staged = /* @__PURE__ */ new WeakMap();
-	let seq = 0;
-	let published = 0;
-	let pulled = 0;
-	const matches = (r, kinds) => !kinds || kinds.includes(r.event.type);
-	const bestIndex = (kinds) => {
-		let best = -1;
-		let bestPriority = Number.NEGATIVE_INFINITY;
-		for (let i = 0; i < queue.length; i++) {
-			const r = queue[i];
-			if (!r || !matches(r, kinds)) continue;
-			if (r.priority > bestPriority) {
-				best = i;
-				bestPriority = r.priority;
-			}
-		}
-		return best;
+	if (!touched) return {
+		ok: true,
+		profile,
+		resolved: []
 	};
 	return {
-		async publish(event, opts) {
-			const record = staged.get(event) ?? {
-				seq: seq++,
-				at: now(),
-				priority: opts?.priority ?? 0,
-				event
-			};
-			staged.set(event, record);
-			for (const handler of subscribers) await handler(record);
-			staged.delete(event);
-			if (opts?.queue !== false) queue.push(record);
-			log.push(record);
-			published += 1;
-			byKind[event.type] = (byKind[event.type] ?? 0) + 1;
-			return record;
-		},
-		pull(kinds) {
-			const i = bestIndex(kinds);
-			if (i < 0) return void 0;
-			pulled++;
-			return queue.splice(i, 1)[0]?.event;
-		},
-		subscribe(handler) {
-			subscribers.push(handler);
-			return () => {
-				const i = subscribers.indexOf(handler);
-				if (i >= 0) subscribers.splice(i, 1);
-			};
+		ok: true,
+		profile: {
+			...profile,
+			resources: next
 		},
-		pending(kinds) {
-			return kinds ? queue.filter((r) => matches(r, kinds)).length : queue.length;
-		},
-		history() {
-			return log;
-		},
-		stats() {
-			return {
-				published,
-				pulled,
-				byKind: { ...byKind }
-			};
-		}
+		resolved
 	};
 }
 //#endregion
@@ -786,7 +756,7 @@ const spawnProfileFields = [
 	},
 	{
 		name: "resources",
-		description: "Files, tools, skills, and agents materialized into the child workspace before it starts. Brief form: `{ files?, tools?, skills?, agents? }`, each an array whose entries are `{ kind: \"inline\", name, content }` or `{ kind: \"github\", repository?, path, ref? }` (`files` entries wrap that as `{ path, resource, executable? }`). A child typically gets `files` for seed inputs and `skills` for a procedure it must follow; the canonical AgentProfile schema carries the full form and governs validation.",
+		description: "Files, tools, skills, and agents materialized into the child workspace before it starts. Brief form: `{ files?, tools?, skills?, agents? }`, each an array whose entries are `{ kind: \"inline\", name, content }`, `{ kind: \"inline\", name, path }`, or `{ kind: \"github\", repository?, path, ref? }` (`files` entries wrap that as `{ path, resource, executable? }`). An inline `path` is relative to YOUR workspace and is read by the runtime, so use it for any file over a few hundred bytes: content you retype in this call arrives truncated and altered, a path arrives byte-exact and the result reports its sha256. A child typically gets `files` for seed inputs and `skills` for a procedure it must follow; the canonical AgentProfile schema carries the full form and governs validation.",
 		brief: {
 			type: "object",
 			properties: {
@@ -1929,7 +1899,16 @@ function createCoordinationTools(opts) {
 					live,
 					freeSlots: freeWorkerSlots()
 				}))(liveWorkerCount()));
-				const parsedProfile = agentProfileSchema.safeParse(a.profile);
+				const resourcePaths = await resolveSpawnResourcePaths(a.profile, opts.spawnResourceRoot);
+				if (!resourcePaths.ok) return {
+					error: "invalid-profile",
+					reason: `resources.${resourcePaths.at}: ${resourcePaths.reason}`,
+					issues: [{
+						path: `resources.${resourcePaths.at}`,
+						message: resourcePaths.reason
+					}]
+				};
+				const parsedProfile = agentProfileSchema.safeParse(resourcePaths.profile);
 				if (!parsedProfile.success) return Promise.resolve({
 					error: "invalid-profile",
 					reason: `the profile you wrote is not a valid AgentProfile: ${parsedProfile.error.issues.map((issue) => `${issue.path.join(".") || "profile"} ${issue.message}`).join("; ")}`,
@@ -2023,7 +2002,8 @@ function createCoordinationTools(opts) {
 					...continuity.continuity === "resume" ? { resume: continuity.resume } : {},
 					live: liveWorkerCount(),
 					freeSlots: freeWorkerSlots(),
-					...priorHistory
+					...priorHistory,
+					...resourcePaths.resolved.length === 0 ? {} : { resourcesFromPath: resourcePaths.resolved }
 				} : {
 					error: res.reason,
 					reason: res.reason === "usd-unbudgeted" ? "this run's root budget declares no maxUsd, so a child budget naming maxUsd can never be admitted at any amount — spawn with a budget that omits maxUsd" : res.reason === "in-doubt" ? "this key has a prior worker recorded as started without a terminal receipt; no replacement was started because that remote worker may still be running — inspect or recover the exact prior execution before retrying" : `the conserved pool refused this spawn (${String(res.reason)}); the run has no allocation left to give this worker`,
@@ -2642,6 +2622,269 @@ function safeJsonText(value) {
 	}
 }
 //#endregion
+//#region src/runtime/supervise/run-cancellation.ts
+/** Apply a durable request through the run's existing abort controller. */
+function applyRunCancellation(dir, abortRun, now, path = "turn-boundary") {
+	const request = readRunCancelRequest(dir);
+	if (request === void 0) return void 0;
+	const prior = readRunCancellation(dir, request.operationId);
+	if (prior !== void 0) return prior;
+	abortRun(request.reason ?? "run cancel requested", request);
+	const observedAt = now();
+	const appliedAfterMs = Math.max(0, Date.parse(observedAt) - Date.parse(request.at));
+	const record = {
+		operationId: request.operationId,
+		effect: "cancel_requested",
+		path,
+		appliedAfterMs,
+		...request.deadlineMs === void 0 ? {} : { deadlineExceeded: appliedAfterMs > request.deadlineMs },
+		requestedAt: request.at,
+		observedAt,
+		...request.reason === void 0 ? {} : { reason: request.reason },
+		detail: "root abort issued to the whole run; termination not yet proven"
+	};
+	writeRunCancellation(dir, record);
+	return record;
+}
+/** External drivers may remain silent indefinitely, so turn boundaries cannot observe control. */
+function watchRunCancellation(dir, abortRun) {
+	mkdirSync(workerCancellationsDir(dir), { recursive: true });
+	let active = true;
+	let failure;
+	const check = (path = "observer") => {
+		if (failure !== void 0) throw failure;
+		if (active) applyRunCancellation(dir, abortRun, () => (/* @__PURE__ */ new Date()).toISOString(), path);
+	};
+	const fail = (error) => {
+		if (!active) return;
+		failure = error;
+		abortRun(`durable run cancellation observer failed: ${String(error)}`);
+	};
+	const watcher = watch(workerCancellationsDir(dir), (_event, filename) => {
+		if (!active || filename !== null && filename !== "run.request.json") return;
+		try {
+			check();
+		} catch (error) {
+			fail(error);
+		}
+	});
+	watcher.on("error", fail);
+	const fallback = setInterval(() => {
+		try {
+			check("fallback");
+		} catch (error) {
+			fail(error);
+		}
+	}, 100);
+	fallback.unref();
+	return {
+		check,
+		close() {
+			active = false;
+			watcher.close();
+			clearInterval(fallback);
+		}
+	};
+}
+//#endregion
+//#region src/runtime/supervise/coordination-log.ts
+/**
+* Durable side-log for coordination evidence the spawn journal does not own: questions, analyst
+* findings, answer decisions, authorized continuation receipts, delivery-attempt markers, and
+* delivery outcomes. A durable run
+* (`supervise({ runDir })`) appends them as they publish and loads them on resume, so a restarted
+* coordinator retains the exact evidence produced by prior processes.
+*
+* Answer down-events also fold status on load: a question answered before the crash reloads as
+* `answered`, not as a re-blocking `open`. Settled events are skipped (the spawn journal is their
+* ledger). A receipt followed by an attempt but no outcome proves the process died in the delivery
+* window; that outcome remains unknown and no prior instruction is auto-delivered.
+*
+* JSONL, one fsynced record per event, keyed by `runId` — several runs may share one log file
+* exactly as they share one spawn-journal file.
+*
+* @experimental
+*/
+/** Persist prior context plus exact continuation authorization, attempt, and result evidence.
+* Settlements have their own journal. */
+function persisted(event) {
+	return event.type !== "settled";
+}
+/** FS-backed `CoordinationLog`: append-only JSONL, fsynced per record. */
+var FileCoordinationLog = class {
+	path;
+	appendTail = Promise.resolve();
+	constructor(path) {
+		this.path = path;
+	}
+	async append(runId, record, ownerId) {
+		if (!persisted(record.event)) return;
+		const append = this.appendTail.then(() => this.appendRecord(runId, record, ownerId));
+		this.appendTail = append.catch(() => void 0);
+		return append;
+	}
+	async appendRecord(runId, busRecord, ownerId) {
+		const fs = await import("node:fs/promises");
+		const path = await import("node:path");
+		await fs.mkdir(path.dirname(this.path), { recursive: true });
+		const record = {
+			runId,
+			...ownerId !== void 0 ? { ownerId } : {},
+			...busRecord
+		};
+		const needsSeparator = await prepareJsonlAppend(this.path);
+		const fh = await fs.open(this.path, "a");
+		try {
+			await writeAllBytes(fh, `${needsSeparator ? "\n" : ""}${JSON.stringify(record)}\n`);
+			await fh.sync();
+		} finally {
+			await fh.close();
+		}
+	}
+	async load(runId, ownerId) {
+		const fs = await import("node:fs/promises");
+		let text;
+		try {
+			text = await fs.readFile(this.path, "utf8");
+		} catch (err) {
+			if (isNoEntError(err)) return emptyPriorCoordination(ownerId);
+			throw err;
+		}
+		const byId = /* @__PURE__ */ new Map();
+		const findings = [];
+		const escalations = [];
+		const analystDefinitions = [];
+		const continuations = [];
+		const deliveryEvidence = [];
+		const mail = [];
+		const records = [];
+		let legacySeq = 0;
+		for (const stored of parseCommittedJsonLines(text, this.path)) {
+			if (stored.runId !== runId) continue;
+			if (ownerId !== void 0 && stored.ownerId !== ownerId) continue;
+			const record = "seq" in stored ? {
+				seq: stored.seq,
+				at: stored.at,
+				priority: stored.priority,
+				event: stored.event
+			} : {
+				seq: legacySeq++,
+				at: Date.parse(stored.at),
+				priority: 0,
+				event: stored.event
+			};
+			records.push(record);
+			const ev = record.event;
+			if (ev.type === "delivery-attempt" || ev.type === "steer" || ev.type === "answer") deliveryEvidence.push(ev);
+			if (ev.type === "question") byId.set(ev.question.id, ev.question);
+			else if (ev.type === "finding") findings.push(ev.finding);
+			else if (ev.type === "answer") {
+				const prior = byId.get(ev.questionId);
+				if (prior && ev.down.delivered) byId.set(ev.questionId, {
+					...prior,
+					status: "answered",
+					decision: {
+						kind: "answer",
+						answer: ev.down.instruction,
+						by: "prior-run"
+					}
+				});
+			} else if (ev.type === "instruction") continuations.push(ev.instruction);
+			else if (ev.type === "mail") mail.push(ev.mail);
+			else if (ev.type === "escalation") escalations.push(ev.escalation);
+			else if (ev.type === "analyst-defined") analystDefinitions.push(ev.analyst);
+		}
+		return {
+			...ownerId !== void 0 ? { ownerId } : {},
+			questions: [...byId.values()],
+			findings,
+			escalations,
+			analystDefinitions,
+			continuations,
+			deliveryEvidence,
+			mail,
+			records
+		};
+	}
+};
+function emptyPriorCoordination(ownerId) {
+	return {
+		...ownerId !== void 0 ? { ownerId } : {},
+		questions: [],
+		findings: [],
+		escalations: [],
+		analystDefinitions: [],
+		continuations: [],
+		deliveryEvidence: [],
+		mail: [],
+		records: []
+	};
+}
+//#endregion
+//#region src/runtime/supervise/run-context.ts
+/**
+*
+* `createInMemoryRunContext` — the one-call bundle of the in-memory stores a
+* `createSupervisor().run(root, task, opts)` needs: a fresh `InMemorySpawnJournal`
+* (the event-sourced spawn log), a fresh `InMemoryResultBlobStore` (the
+* content-addressed `outRef` payload store the driver's `observe`/`finalize` reads
+* settled outputs through), and a fresh `createExecutorRegistry()` (the open
+* `AgentSpec → Executor` resolver).
+*
+* It exists to kill the boilerplate every offline/local supervised run repeats by
+* hand — three constructors threaded into `SupervisorOpts` — and to single-source the
+* ONE wiring invariant that is easy to get wrong: when the root is the recursive
+* `driverAgent` LLM-driver brain AND it may spawn nested managed children, the registry MUST be
+* wrapped with `withDriverExecutor` so a child constructed by `driverChild` resolves to the
+* nested-scope executor — and that SAME blob
+* store MUST be the one passed to `driverAgent({ blobs })`, or the driver
+* reads from a different store than the scope writes to. Pass `{ withDriver: true }`
+* and reuse the returned `blobs` for both.
+*
+* The spread shape matches `SupervisorOpts` exactly, so the call site reads:
+*   const run = createInMemoryRunContext()
+*   await createSupervisor().run(root, task, { budget, runId, ...run })
+*
+* @experimental
+*/
+/**
+* Build a fresh in-memory run context. Every call returns NEW stores (no shared global
+* state between runs), so two runs never cross-contaminate their journals/blobs.
+*/
+function createInMemoryRunContext(opts = {}) {
+	const base = createExecutorRegistry();
+	return {
+		journal: new InMemorySpawnJournal(),
+		blobs: new InMemoryResultBlobStore(),
+		executors: opts.withDriver ? withDriverExecutor(base) : base
+	};
+}
+/**
+* Build a DURABLE run context: the spawn journal and the result blobs are file-backed (fsynced
+* per append/write) under `dir`, and the context carries `resume: true` so spreading it into
+* `SupervisorOpts` makes the supervisor `loadTree`-first. A run that dies mid-flight therefore
+* resumes when it is re-run with the SAME `runId` and the SAME `dir`: the committed children come
+* back on `Scope.resume` (rehydrated by `replaySpawnTree`) instead of being re-executed.
+*
+* Layout: `${dir}/spawn-journal.jsonl` (one JSONL record per event), `${dir}/blobs/` (one
+* content-addressed JSON file per settled result), and `${dir}/coordination-log.jsonl`
+* (questions, findings, answer decisions, and authorized continuation receipts retained as
+* evidence). The directory is created on first write.
+*
+* Opt-in by construction — `createInMemoryRunContext()` is unchanged and stays the default, so no
+* existing consumer writes to disk or resumes unless it asks for this.
+*/
+function createFileRunContext(dir, opts = {}) {
+	const base = createExecutorRegistry();
+	return {
+		journal: new FileSpawnJournal(`${dir}/spawn-journal.jsonl`),
+		blobs: new FileResultBlobStore(`${dir}/blobs`),
+		executors: opts.withDriver ? withDriverExecutor(base) : base,
+		resume: true,
+		coordinationLog: new FileCoordinationLog(`${dir}/coordination-log.jsonl`)
+	};
+}
+//#endregion
 //#region src/runtime/anytime.ts
 /**
 * The best-so-far fold — the ONE definition of "how good was the run after k results", shared by
@@ -3480,6 +3723,7 @@ function driverAgent(opts) {
 				...opts.continuityByProfile ? { continuityByProfile: opts.continuityByProfile } : {},
 				...opts.preflightSpawn ? { preflightSpawn: opts.preflightSpawn } : {},
 				...opts.resolveSpawnProfile ? { resolveSpawnProfile: opts.resolveSpawnProfile } : {},
+				...opts.spawnResourceRoot ? { spawnResourceRoot: opts.spawnResourceRoot } : {},
 				...opts.escalateQuestion ? { escalateQuestion: opts.escalateQuestion } : {},
 				...opts.onEvent ? { onEvent: opts.onEvent } : {},
 				...opts.replaySettlements ? { replaySettlements: true } : {},
@@ -3811,6 +4055,6 @@ function errMessage(e) {
 	return e instanceof Error ? e.message : String(e);
 }
 //#endregion
-export { watchTrace as A, createCoordinationTools as C, questionEscalationTargets as D, parseAuthoredAnalystDefinition as E, watchRunCancellation as F, createInMemoryRunContext as M, FileCoordinationLog as N, createEventBus as O, applyRunCancellation as P, coordinationVerbNames as S, normalizeAnalyzeOnSettle as T, renderAnytimeTable as _, allOf as a, analystToolGroupNames as b, createProgressTracker as c, progressStop as d, sampleFromSettled as f, plateauLength as g, bestSoFar as h, finalizeBestDelivered as i, createFileRunContext as j, defaultToolDetectors 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, ANALYST_DEFINITION_BOUNDS as v, downMessageRefusalReasons as w, canonicalFindingEvent as x, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as y };
+export { normalizeAnalyzeOnSettle as A, ANALYST_DEFINITION_BOUNDS as C, coordinationVerbNames as D, canonicalFindingEvent as E, watchTrace as F, questionEscalationTargets as M, createEventBus as N, createCoordinationTools as O, defaultToolDetectors 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, parseAuthoredAnalystDefinition as j, downMessageRefusalReasons 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-CvinSUI-.js.map
+//# sourceMappingURL=coordination-driver-BxGh-Tnj.js.map