@tangle-network/agent-runtime 1.0.0 → 2.0.2

package/dist/{coordination-manager-ewBF777W.js → coordination-manager-BZLp9qpE.js}

@@ -1,6 +1,9 @@
-import { Tt as assertValidBudget, b as captureRunWriteContext, c as readCommittedJsonLines, et as detachedFrozen, ft as errMessage, i as appendCommittedJsonLine, j as settlementFailureCause, r as spawnJournalRecordEvents, rt as contentAddress, t as FileSpawnJournal, vt as resolveRedactor } from "./journal-store-BJPMUydp.js";
-import { $n as CheckUnavailableError, An as createPeerMailbox, Cn as INBOX_RECEIPT_KEY, L as runtimeGraphMetadataKey, Q as resolveSpawnResourcePaths, Rn as isLiveNodeStatus, S as workerTraceAnalysisStore, W as meterRuntimeOwnedAccounting, _ as withDriverExecutor, _t as FileResultBlobStore, gt as InMemorySpawnJournal, ht as InMemoryResultBlobStore, lr as failedItems, sr as checkVerdictOf, vt as createExecutorRegistry, x as parseWorkerToolTraceArtifact, zn as isTerminalNodeStatus } from "./supervisor-hHU3ZJnR.js";
-import { C as writeWorkerCancellation, T as writeWorkerSteerAcknowledgement, c as writeRunCancellation, g as readWorkerSteerRequests, h as readWorkerSteerAcknowledgement, i as readRunCancellation, m as readWorkerCancellation, p as readWorkerCancelRequests, r as readRunCancelRequest, t as applyRunCancellation, u as claimWorkerSteerDelivery } from "./run-cancellation-CoJRKvih.js";
+import { L as runtimeGraphMetadataKey, Ln as isLiveNodeStatus, Q as resolveSpawnResourcePaths, Qn as CheckUnavailableError, Rn as isTerminalNodeStatus, S as workerTraceAnalysisStore, Sn as INBOX_RECEIPT_KEY, W as meterRuntimeOwnedAccounting, _ as withDriverExecutor, _t as createExecutorRegistry, cr as failedItems, gt as InMemorySpawnJournal, ht as InMemoryResultBlobStore, kn as createPeerMailbox, or as checkVerdictOf, x as parseWorkerToolTraceArtifact } from "./supervisor-L7u3pQ1j.js";
+import { H as contentAddress, i as FileResultBlobStore, nt as assertValidBudget, r as spawnJournalRecordEvents, t as FileSpawnJournal, y as settlementFailureCause } from "./journal-store-BpCOCDoO.js";
+import { b as resolveRedactor, m as errMessage, o as readCommittedJsonLines, t as appendCommittedJsonLine, u as detachedFrozen } from "./jsonl-file-BBP9Dz9w.js";
+import { o as captureRunWriteContext } from "./durable-file-DstVeHcj.js";
+import { C as writeWorkerCancellation, T as writeWorkerSteerAcknowledgement, c as writeRunCancellation, g as readWorkerSteerRequests, h as readWorkerSteerAcknowledgement, i as readRunCancellation, m as readWorkerCancellation, p as readWorkerCancelRequests, r as readRunCancelRequest, t as applyRunCancellation, u as claimWorkerSteerDelivery } from "./run-cancellation-Cpm-BIUu.js";
+import { a as admitRuntimeSpawn, i as workerSettlement, n as resolveJsonPointer, o as safeJsonText, r as textBytes, t as createMapRouting } from "./coordination-map-routing-CUvwHAtv.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest } from "@tangle-network/agent-interface";
 import { argHash, errorStreakDetector, observeAll, repeatedActionDetector } from "@tangle-network/agent-eval";
 import { registry } from "zod";
@@ -192,17 +195,6 @@ function createFileRunContext(dir, opts = {}) {
 		coordinationLog: new FileCoordinationLog(`${dir}/coordination-log.jsonl`)
 	};
 }
-// src/mcp/tools/coordination-json.ts
-/** Stringify a findings payload for a routed delivery; never throws (a cyclic payload degrades to
-*  its String form rather than killing the settle path). */
-function safeJsonText(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
 // src/mcp/tools/coordination-events.ts
 /** Default and maximum bounds for one {@link CoordinationTools} journal read. The defaults are
 *  sized for a driver turn (a page a model can read and still have room to act on); the maxima
@@ -2564,353 +2556,6 @@ async function awaitSettlement(env, workerIds, signal) {
 		})])) && settledIds().length === 0) return [];
 	}
 }
-// src/mcp/tools/coordination-runtime-spawn.ts
-/**
-* Admit one keyed runtime spawn. A key whose prior worker is in doubt (started in a dead process
-* with no terminal receipt) is re-admitted once under `<key>#2`, the replacement key the
-* `spawn_worker` contract names; a replacement that is in doubt too is reported, never retried.
-*/
-async function admitRuntimeSpawn(admitSpawn, input) {
-	for (const key of [input.key, `${input.key}#2`]) {
-		let response;
-		try {
-			response = await admitSpawn({
-				...input,
-				key
-			});
-		} catch (error) {
-			return { refused: errMessage(error) };
-		}
-		const started = response;
-		if (typeof started.workerId === "string") return {
-			workerId: started.workerId,
-			committed: started.resumed === "completed"
-		};
-		if (started.error !== "in-doubt") return { refused: typeof started.reason === "string" ? started.reason : "spawn refused" };
-	}
-	return { inDoubt: true };
-}
-// src/mcp/tools/coordination-map-routing.ts
-function createMapRouting(deps) {
-	const state = {
-		...deps,
-		mapRoutes: deps.opts.mapOnSettle ?? [],
-		mapMembers: /* @__PURE__ */ new Map(),
-		liveExpansions: /* @__PURE__ */ new Map()
-	};
-	return {
-		isItem: (workerId) => state.mapMembers.get(workerId)?.role === "item",
-		settleMapMember: settleMapMember.bind(null, state),
-		expandMaps: expandMaps.bind(null, state),
-		runMapStep: runMapStep.bind(null, state)
-	};
-}
-const textBytes = (value) => Buffer.byteLength(safeJsonText(value), "utf8");
-async function publishMap({ bus }, event, wake = false) {
-	const record = detachedFrozen({
-		type: "map",
-		map: event
-	});
-	if (wake) await bus.publish(record);
-	else await bus.publish(record, { queue: false });
-}
-function workerSlotBound({ opts }) {
-	const capacity = opts.scope.workerCapacity;
-	if (capacity === void 0 || capacity.freeSlots === null) return void 0;
-	return capacity.working + capacity.freeSlots;
-}
-async function startMapSpawn(state, expansion, role, profile, task, index) {
-	const { opts } = state;
-	const { route } = expansion;
-	const name = typeof profile.name === "string" && profile.name.length > 0 ? profile.name : "worker";
-	const spawned = await admitRuntimeSpawn(state.admitSpawn, {
-		profile,
-		args: {
-			label: index === void 0 ? name : `${name}#${index}`,
-			...role === "item" && route.itemBudget !== void 0 ? { budget: route.itemBudget } : {}
-		},
-		task,
-		key: `map:${route.edge}#${expansion.expansion}:${index ?? "join"}`,
-		continuity: { continuity: "fresh" },
-		successorOf: void 0,
-		preflightProfile: () => opts.resolveSpawnProfile ? detachedFrozen(opts.resolveSpawnProfile(profile)) : profile,
-		resourcesFromPath: [],
-		defaultLabel: name,
-		map: Object.freeze({
-			edge: route.edge,
-			role,
-			...index === void 0 ? {} : { index }
-		})
-	});
-	if ("inDoubt" in spawned) {
-		await state.endInDoubt(name, expansion.sourceWorker);
-		return { refused: `in-doubt:${name}` };
-	}
-	if ("refused" in spawned) return spawned;
-	state.mapMembers.set(spawned.workerId, {
-		expansion,
-		role,
-		...index === void 0 ? {} : { index },
-		bytes: textBytes(task)
-	});
-	if (role === "item") expansion.inFlight += 1;
-	if (spawned.committed) await state.settleCommitted(spawned.workerId, name);
-	return { workerId: spawned.workerId };
-}
-async function mapItemProfile({ opts }, route) {
-	if ("profile" in route.item) return { profile: route.item.profile };
-	if (!opts.graphs) return { refused: "a graph item starts through run_graph, which this manager does not serve" };
-	const prepared = await opts.graphs.prepare({ graph: route.item.graph });
-	return prepared.ok ? { profile: detachedFrozen(prepared.profile) } : { refused: prepared.reason };
-}
-/** Record an item that never ran, and tell the manager. */
-async function recordUnstartedItem(state, expansion, index, reason) {
-	expansion.settlements[index] = {
-		outcome: "unpropagated",
-		reason
-	};
-	await publishMap(state, {
-		edge: expansion.route.edge,
-		phase: "item",
-		outcome: "unpropagated",
-		sourceWorker: expansion.sourceWorker,
-		index,
-		bytes: 0,
-		reason
-	});
-}
-async function startMapItem(state, expansion, index) {
-	const { route } = expansion;
-	const resolved = await mapItemProfile(state, route);
-	const started = "refused" in resolved ? resolved : await startMapSpawn(state, expansion, "item", resolved.profile, expansion.items[index], index);
-	if ("workerId" in started) return;
-	if (route.onItemFailure === "all-or-refuse") expansion.stopped = true;
-	await recordUnstartedItem(state, expansion, index, `item spawn refused: ${started.refused}`);
-}
-async function pumpMap(state, expansion) {
-	const { route, items } = expansion;
-	while (!expansion.stopped && expansion.inFlight < route.concurrency && expansion.next < items.length) {
-		const index = expansion.next;
-		expansion.next += 1;
-		await startMapItem(state, expansion, index);
-	}
-	if (expansion.inFlight === 0) await finishMap(state, expansion);
-}
-async function finishMap(state, expansion, closed) {
-	if (expansion.finished) return;
-	expansion.finished = true;
-	const { route, items, sourceWorker } = expansion;
-	for (let index = expansion.next; index < items.length; index += 1) await recordUnstartedItem(state, expansion, index, closed ?? "not started: all-or-refuse stopped this map after an item failed");
-	expansion.next = items.length;
-	const { results, failures } = collectJoinInputs(expansion);
-	const refusal = closed ?? (route.onItemFailure === "all-or-refuse" && failures.length > 0 ? `all-or-refuse: ${failures.length} of ${items.length} items did not deliver (${failures.map((failure) => `#${failure.index} ${failure.outcome}: ${failure.reason}`).join("; ")}); the join did not run` : void 0);
-	if (refusal !== void 0) {
-		await publishMap(state, {
-			edge: route.edge,
-			phase: "join",
-			outcome: "unpropagated",
-			sourceWorker,
-			bytes: 0,
-			reason: refusal
-		}, closed === void 0);
-		return;
-	}
-	const task = {
-		map: route.edge,
-		source: sourceWorker,
-		items: items.length,
-		results,
-		failures
-	};
-	const started = await startMapSpawn(state, expansion, "join", route.join, task, void 0);
-	if ("refused" in started) await publishMap(state, {
-		edge: route.edge,
-		phase: "join",
-		outcome: "unpropagated",
-		sourceWorker,
-		bytes: 0,
-		reason: `join spawn refused: ${started.refused}`
-	}, true);
-}
-/** Split an expansion's settlements into the delivered results and the failures, in item order. */
-function collectJoinInputs(expansion) {
-	const results = [];
-	const failures = [];
-	expansion.items.forEach((item, index) => {
-		const settlement = expansion.settlements[index];
-		if (settlement?.outcome === "delivered") results.push({
-			index,
-			item,
-			result: settlement.result
-		});
-		else failures.push({
-			index,
-			item,
-			outcome: settlement?.outcome ?? "unpropagated",
-			reason: settlement?.reason ?? "never settled"
-		});
-	});
-	return {
-		results,
-		failures
-	};
-}
-async function settleMapMember(state, settled, worker, advance) {
-	const member = state.mapMembers.get(worker.id);
-	if (member === void 0) return;
-	state.mapMembers.delete(worker.id);
-	const { expansion, role, index, bytes } = member;
-	const settlement = workerSettlement(settled, worker);
-	await publishMap(state, {
-		edge: expansion.route.edge,
-		phase: role,
-		outcome: settlement.outcome,
-		sourceWorker: expansion.sourceWorker,
-		...index === void 0 ? {} : { index },
-		workerId: worker.id,
-		bytes,
-		...settlement.reason === void 0 ? {} : { reason: settlement.reason }
-	});
-	if (role === "join" || index === void 0) return;
-	expansion.inFlight -= 1;
-	expansion.settlements[index] = settlement;
-	if (settlement.outcome !== "delivered" && expansion.route.onItemFailure === "all-or-refuse") expansion.stopped = true;
-	if (advance) await pumpMap(state, expansion);
-	else if (expansion.inFlight === 0) await finishMap(state, expansion, "not started: the manager stopped before this map finished");
-}
-function expansionOf(state, source, workerId) {
-	const resume = state.opts.scope.resume;
-	const labels = new Map(resume?.view.nodes.map((node) => [node.id, node.label]) ?? []);
-	const prior = (resume?.settled ?? []).filter((s) => s.kind === "done" && labels.get(s.handle.id) === source).map((s) => s.handle.id);
-	const rank = prior.indexOf(workerId);
-	if (rank >= 0) return rank + 1;
-	let journaled = 0;
-	for (const route of state.mapRoutes) {
-		if (route.from !== source) continue;
-		const prefix = `key:map:${route.edge}#`;
-		for (const node of resume?.view.nodes ?? []) {
-			if (!node.assignmentId?.startsWith(prefix)) continue;
-			const n = Number.parseInt(node.assignmentId.slice(prefix.length), 10);
-			if (Number.isSafeInteger(n)) journaled = Math.max(journaled, n);
-		}
-	}
-	const live = (state.liveExpansions.get(source) ?? 0) + 1;
-	state.liveExpansions.set(source, live);
-	return Math.max(prior.length, journaled) + live;
-}
-/** The list a map expands over, or the reason no item runs. */
-function resolveMapItems(state, out, route) {
-	const selected = resolveJsonPointer(out, route.pointer);
-	if (!selected.found) return { refusal: `pointer ${JSON.stringify(route.pointer)} does not resolve in the source result: ${selected.reason}; no item ran` };
-	const items = selected.value;
-	if (!Array.isArray(items)) return { refusal: `pointer ${JSON.stringify(route.pointer)} resolves to ${items === null ? "null" : typeof items}, not an array; no item ran` };
-	if (items.length > route.maxItems) return { refusal: `max-items-exceeded: the list holds ${items.length} items and this map admits at most ${route.maxItems}; no item ran` };
-	const slots = workerSlotBound(state);
-	if (slots !== void 0 && route.concurrency > slots) return { refusal: `concurrency-unsatisfiable: concurrency ${route.concurrency} exceeds this run's ${slots} worker slots, so the cap could never be honored; no item ran` };
-	return { items };
-}
-async function expandMaps(state, settled, worker) {
-	const { mapRoutes } = state;
-	if (settled.kind !== "done" || mapRoutes.length === 0) return;
-	const name = state.nodeOf(worker.id);
-	if (name === void 0 || !mapRoutes.some((route) => route.from === name)) return;
-	const expansion = expansionOf(state, name, worker.id);
-	for (const route of mapRoutes) {
-		if (route.from !== name) continue;
-		const resolved = resolveMapItems(state, settled.out, route);
-		if ("refusal" in resolved) {
-			await publishMap(state, {
-				edge: route.edge,
-				phase: "expand",
-				outcome: "unpropagated",
-				sourceWorker: worker.id,
-				bytes: 0,
-				reason: resolved.refusal
-			}, true);
-			continue;
-		}
-		const { items } = resolved;
-		await publishMap(state, {
-			edge: route.edge,
-			phase: "expand",
-			outcome: items.length === 0 ? "empty" : "delivered",
-			sourceWorker: worker.id,
-			bytes: textBytes(items),
-			items: items.length,
-			...items.length === 0 ? { reason: "the list is empty; the join runs with no results" } : {}
-		});
-		await pumpMap(state, {
-			route,
-			sourceWorker: worker.id,
-			expansion,
-			items: detachedFrozen(items),
-			settlements: [],
-			next: 0,
-			inFlight: 0,
-			stopped: false,
-			finished: false
-		});
-	}
-}
-async function runMapStep({ opts }, step, worker) {
-	try {
-		await step();
-	} catch (error) {
-		console.error("Runtime map step failed", {
-			managerId: opts.scope.view.root,
-			worker: worker.id,
-			error: errMessage(error)
-		});
-	}
-}
-function workerSettlement(settled, worker) {
-	if (settled.kind !== "done" || worker.status !== "done") return {
-		outcome: "failed",
-		reason: worker.status === "down" ? worker.reason : "down"
-	};
-	if (worker.valid === false) return {
-		outcome: "failed",
-		reason: "its deliverable check rejected the result"
-	};
-	if (settled.out === void 0) return {
-		outcome: "empty",
-		reason: "it settled with no result"
-	};
-	return {
-		outcome: "delivered",
-		result: settled.out
-	};
-}
-/** Resolve an RFC 6901 JSON pointer (`''` is the whole document). */
-function resolveJsonPointer(document, pointer) {
-	if (pointer === "") return {
-		found: true,
-		value: document
-	};
-	if (!pointer.startsWith("/")) return {
-		found: false,
-		reason: "a JSON pointer is empty or starts with \"/\""
-	};
-	let value = document;
-	for (const raw of pointer.slice(1).split("/")) {
-		const token = raw.replaceAll("~1", "/").replaceAll("~0", "~");
-		if (Array.isArray(value)) {
-			if (!/^(0|[1-9]\d*)$/.test(token) || Number(token) >= value.length) return {
-				found: false,
-				reason: `no index ${JSON.stringify(token)} in an array of ${value.length}`
-			};
-			value = value[Number(token)];
-		} else if (typeof value === "object" && value !== null && Object.hasOwn(value, token)) value = value[token];
-		else return {
-			found: false,
-			reason: `no member ${JSON.stringify(token)}`
-		};
-	}
-	return {
-		found: true,
-		value
-	};
-}
 // src/mcp/tools/coordination-question-ledger.ts
 function createQuestionLedger({ opts, bus }) {
 	let questionSeq = 0;
@@ -5580,6 +5225,6 @@ function createResumeReplay({ opts, bus, ledger, analysis, projectSettled }) {
 		return readyInFlight;
 	};
 }
-export { FileCoordinationLog as _, downMessageRefusalReasons as a, createCancelAcknowledger as c, normalizeAnalyzeOnSettle as d, coordinationVerbNames as f, withRunContext as g, createInMemoryRunContext as h, watchTrace as i, createSteerAcknowledger as l, createFileRunContext as m, createCoordinationToolsForManager as n, resolveJsonPointer as o, safeJsonText as p, defaultToolDetectors as r, createEventBus as s, createCoordinationTools as t, budgetOverspendText as u, foldCoordinationRecords as v };
+export { downMessageRefusalReasons as a, createSteerAcknowledger as c, coordinationVerbNames as d, createFileRunContext as f, foldCoordinationRecords as g, FileCoordinationLog as h, 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-ewBF777W.js.map
+//# sourceMappingURL=coordination-manager-BZLp9qpE.js.map