@tangle-network/agent-runtime 2.3.9 → 2.3.11

package/dist/durable.js

@@ -1,150 +1,24 @@
-import { cr as failedItems, i as RunParkedError, lr as isFiniteNumber, pt as loadSpawnForest, qr as authoredProfileDigest, r as assertResumeLimits, s as readRunParking } from "./supervisor-Bs9ie39Q.js";
+import { Kr as runtimeFailureCause, L as FileSpawnJournal, Vt as loadSpawnForest, _ as supervisorRunDir, a as readRootStream, br as authoredProfileDigest, dn as FileObserverJournal, fn as createFileObserverHooks, o as readRootStreamReceipt, pi as contentAddress, pn as observerRecordDigest, qt as FileResultBlobStore, wi as assertValidBudget, y as workerCancellationsDir } from "./scope-DRaBilEX.js";
 import { f as RuntimeRunStateError, m as ValidationError } from "./errors-AzSuGI23.js";
-import { c as errorMessage } from "./util-BX20UJ9X.js";
-import { C as FileSpawnJournal, E as FileResultBlobStore, L as runtimeFailureCause, M as FileObserverJournal, N as createFileObserverHooks, P as observerRecordDigest, a as readRootStreamReceipt, g as supervisorRunDir, i as readRootStream, ut as contentAddress, v as workerCancellationsDir, wt as assertValidBudget } from "./root-stream-Bsh5WFcg.js";
+import { J as errorMessage } from "./workspace-streams-Dep2L6XD.js";
 import { n as isNoEntError } from "./jsonl-file-BBP9Dz9w.js";
+import { Et as isFiniteNumber, Tt as failedItems, i as RunParkedError, r as assertResumeLimits, s as readRunParking } from "./supervisor-3JHXy3tz.js";
 import { a as writeAtomicDurableFile, c as mutateRunClaim, i as syncDurableDirectory, l as runGenerationPath, r as publishExclusiveDurableFile, s as fenceRunWrite, u as runWithWriteClaim } from "./durable-file-DstVeHcj.js";
 import { a as withPursuitContext, t as composeRuntimeHooks } from "./runtime-hooks-CsW2pfFk.js";
-import { a as applyExactAgentProfileDiff } from "./profile-Dir2A1_2.js";
-import { a as superviseRootProfile, p as runToolSpans, t as supervise } from "./supervise-DDbwLfA2.js";
-import { a as runCancelRequestFile, o as runCancellationFile } from "./run-cancellation-CzQZUlHr.js";
-import { a as graphExecutionOptions, i as superviseAgentGraph } from "./graph-BWHLetIG.js";
+import { a as applyExactAgentProfileDiff } from "./profile-BzzmKuIX.js";
+import { a as runCancelRequestFile, h as rootCoordinationOwner, o as runCancellationFile, v as FileCoordinationLog } from "./run-cancellation-BxoFCpJ_.js";
+import { a as superviseRootProfile, p as runToolSpans, t as supervise } from "./supervise-6BCQ73Xa.js";
+import { a as graphExecutionOptions, i as superviseAgentGraph } from "./graph-ByNMeS0j.js";
 import { n as handleChatTurn, t as deriveExecutionId } from "./execution-handle-Bd2_nUB6.js";
-import { n as projectPursuit, t as discoverDurableSupervisionRun } from "./supervision-discovery-DmDWHwLu.js";
-import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, canonicalCandidateJson, sha256Bytes } from "@tangle-network/agent-interface";
+import { a as parseSettleRecord, c as settleRecordDigest, d as projectPursuit, i as SettledRunDirectoryError, l as writeFailureRecord, n as FAILURE_RECORD_FILE, o as readFailureRecord, r as SETTLE_RECORD_FILE, s as readSettleRecord, t as discoverDurableSupervisionRun, u as writeSettleRecord } from "./supervision-discovery-Da5zebY2.js";
+import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, sha256Bytes } from "@tangle-network/agent-interface";
 import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { access, readFile, realpath } from "node:fs/promises";
+import { lockHolderVerdict, lockIdentity, parseLockHolderRecord, readLockHolderIdentity } from "@tangle-network/agent-eval/lock-holder";
 import { SearchRecorder, developmentClaim, incumbent, openSearchLedger, parseSearchLedgerLine, runSearch, uniform } from "@tangle-network/agent-eval/campaign";
 import { pathToFileURL } from "node:url";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { lockHolderVerdict, lockIdentity, parseLockHolderRecord, readLockHolderIdentity } from "@tangle-network/agent-eval/lock-holder";
-// src/durable/settle-record.ts
-/** The settle record: the returned `SupervisedResult` as canonical JSON, written once. */
-const SETTLE_RECORD_FILE = "result.json";
-/** The failure record: the most recent throw, replaced by a later throw. */
-const FAILURE_RECORD_FILE = "failure.json";
-/** The directory already holds a settle record, so the run it records must not be re-entered. */
-var SettledRunDirectoryError = class extends Error {
-	path;
-	/** The root of the recorded run, which is its `runId`. */
-	recordedRunId;
-	constructor(path, recordedRunId, requestedRunId) {
-		super(recordedRunId === requestedRunId ? `supervisePursuit: ${path} records that run '${recordedRunId}' already settled; a settled run is not re-entered unless the call passes reopen: { operator, reason, operationId }` : `supervisePursuit: ${path} records that run '${recordedRunId}' already settled in this directory; a directory holds one settle record, so run '${requestedRunId}' needs its own runDir`);
-		this.name = "SettledRunDirectoryError";
-		this.path = path;
-		this.recordedRunId = recordedRunId;
-	}
-};
-/** A result member whose JSON form would misstate it. */
-var UnrecordableSettleValueError = class extends TypeError {
-	path;
-	constructor(path, kind) {
-		super(`supervisePursuit: result${path} is a ${kind}, which JSON cannot record faithfully; a settle record holds plain data only`);
-		this.name = "UnrecordableSettleValueError";
-		this.path = path;
-	}
-};
-const PLAIN_PROTOTYPES = /* @__PURE__ */ new Set([
-	Object.prototype,
-	Array.prototype,
-	null
-]);
-/**
-* The JSON value of a result, or a throw naming the first member JSON would misstate. An
-* `undefined` member and a function are dropped, exactly as any JSON consumer drops them; a Map,
-* a Set, a Date, a typed array, or a class instance would be rewritten to `{}` or a string and
-* so is refused.
-*/
-function jsonValue(result) {
-	const seen = [];
-	const visit = (value, path) => {
-		if (value === null || typeof value !== "object") return;
-		if (value instanceof Map) throw new UnrecordableSettleValueError(path, "Map");
-		if (value instanceof Set) throw new UnrecordableSettleValueError(path, "Set");
-		if (value instanceof Date) throw new UnrecordableSettleValueError(path, "Date");
-		if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) throw new UnrecordableSettleValueError(path, "binary buffer");
-		if (!PLAIN_PROTOTYPES.has(Object.getPrototypeOf(value))) throw new UnrecordableSettleValueError(path, "class instance");
-		if (seen.includes(value)) throw new UnrecordableSettleValueError(path, "cycle");
-		seen.push(value);
-		if (Array.isArray(value)) for (const [index, item] of value.entries()) visit(item, `${path}[${index}]`);
-		else for (const [key, item] of Object.entries(value)) visit(item, `${path}.${key}`);
-		seen.pop();
-	};
-	visit(result, "");
-	return JSON.parse(JSON.stringify(result));
-}
-/**
-* The exact bytes `result.json` holds for a result: its JSON value serialized as RFC 8785
-* canonical JSON. Throws `UnrecordableSettleValueError` before any byte is written when the
-* result carries a value JSON would misstate.
-*/
-function settleRecordJson(result) {
-	return canonicalCandidateJson(jsonValue(result));
-}
-/** The digest the settle record's bytes hash to: the candidate digest of the result's JSON value. */
-function settleRecordDigest(result) {
-	return canonicalCandidateDigest(jsonValue(result));
-}
-/** Publish `result.json` in the run directory once. Throws when a record is already there. */
-async function writeSettleRecord(runDir, result) {
-	const path = resolve(runDir, SETTLE_RECORD_FILE);
-	if (!publishExclusiveDurableFile(path, settleRecordJson(result))) throw new Error(`supervisePursuit: ${path} already exists; a settle record is written once`);
-	return path;
-}
-/** Replace `failure.json` in the run directory with the most recent throw. */
-async function writeFailureRecord(runDir, record) {
-	const path = resolve(runDir, FAILURE_RECORD_FILE);
-	writeAtomicDurableFile(path, `${JSON.stringify(record, null, 2)}\n`);
-	return path;
-}
-/**
-* Read the settle record a run directory holds, or `undefined` when it holds none. A file that
-* is present but is not a settle record is corruption and fails loud.
-*/
-async function readSettleRecord(runDir) {
-	const path = resolve(runDir, SETTLE_RECORD_FILE);
-	let text;
-	try {
-		text = await readFile(path, "utf8");
-	} catch (error) {
-		if (isNoEntError(error)) return void 0;
-		throw error;
-	}
-	return parseSettleRecord(text, path);
-}
-/** Parse settle-record bytes already read, so a caller hashes and parses the same bytes. */
-function parseSettleRecord(text, path) {
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch (cause) {
-		throw new Error(`supervisePursuit: ${path} is not valid JSON`, { cause });
-	}
-	const record = parsed;
-	if (typeof record !== "object" || record === null || typeof record.kind !== "string" || typeof record.tree !== "object" || record.tree === null || typeof record.tree.root !== "string") throw new Error(`supervisePursuit: ${path} is not a settle record (no kind or tree.root)`);
-	return parsed;
-}
-/** Read the most recent failure record, or `undefined` when the directory holds none. */
-async function readFailureRecord(runDir) {
-	const path = resolve(runDir, FAILURE_RECORD_FILE);
-	let text;
-	try {
-		text = await readFile(path, "utf8");
-	} catch (error) {
-		if (isNoEntError(error)) return void 0;
-		throw error;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch (cause) {
-		throw new Error(`supervisePursuit: ${path} is not valid JSON`, { cause });
-	}
-	const record = parsed;
-	if (typeof record !== "object" || record === null || typeof record.runId !== "string" || typeof record.pursuitId !== "string" || typeof record.at !== "string" || typeof record.error?.name !== "string" || typeof record.error.message !== "string" || record.rootStream !== void 0 && (typeof record.rootStream.ref !== "string" || typeof record.rootStream.events !== "number")) throw new Error(`supervisePursuit: ${path} is not a failure record`);
-	return parsed;
-}
 // src/durable/pursuit-version-evidence.ts
 /** The chain's directory beside the first version's: the ledger and its content blobs. */
 function pursuitVersionsLedgerPath(runDir) {
@@ -1589,24 +1463,14 @@ var SupervisePursuitError = class extends Error {
 	}
 };
 /**
-* One-call durable pursuit execution over the canonical `supervise()` kernel.
+* Execute `supervise()` with a durable observer and return its verified pursuit projection.
+* Each `runDir` owns its lock and journals; Intelligence joins directories by `pursuitId`.
+* Agents never receive the observer path or projection.
 *
-* This is an adapter, not a second executor: it composes a durable third-person
-* observer into Runtime's existing recursive hook stream and then rebuilds the
-* operator projection after the same `supervise()` call settles. Agents never
-* receive the observer path or projection and their behavior does not depend on it.
-*
-* Every concrete execution writes only inside its own `runDir`. Cross-run pursuit
-* aggregation is therefore lock-free at the observer layer: reuse `pursuitId` across
-* run directories and let Intelligence join the independently verified projections.
-*
-* The directory's terminal state is recorded beside `observer.jsonl`: `result.json` holds the
-* returned result once the run settles and `failure.json` the most recent throw. A directory
-* whose `result.json` exists refuses re-entry before any compute; a failure record alone does
-* not, because a caller can correct its input and drive the same run again. For the life of the
-* call the directory is held by `supervise.lock`, so a second process on the same directory
-* refuses and names the holder instead of sharing one journal.
-* An abandoned `supervise.lock.guard` requires removal after confirming no lock mutation is active.
+* `result.json` seals a segment and refuses re-entry before compute; `failure.json` records
+* the latest throw and permits a corrected retry. Both pursuit entrypoints use the same
+* directory lifecycle below. A competing process is refused with the lock holder's identity;
+* an abandoned `supervise.lock.guard` requires confirmation of inactivity before removal.
 */
 async function supervisePursuit(profile, task, opts) {
 	assertPursuitDirectory(opts, "supervisePursuit");
@@ -1624,32 +1488,13 @@ async function supervisePursuit(profile, task, opts) {
 		steerDir,
 		retainedAtSettlement: "release",
 		hooks
-	}), (result) => result, reopen === void 0 ? void 0 : (observer) => reopenSettledRun({
-		runDir: opts.runDir.trim(),
-		runId: opts.runId ?? "supervise",
-		reopen,
-		journal: opts.journal,
-		limits: {
-			budget: opts.budget,
-			...opts.reservationPolicy === void 0 ? {} : { reservationPolicy: opts.reservationPolicy }
-		},
-		observer,
-		pursuitId: opts.pursuitId.trim(),
-		now: opts.now ?? Date.now
-	}));
+	}), (result) => result, opts.budget);
 }
 /**
-* One-call durable execution of an `AgentGraph`: the graph twin of {@link supervisePursuit}.
-*
-* It owns the run directory exactly as `supervisePursuit` does — `supervise.lock` for the life of
-* the call, `observer.jsonl`, `result.json` once the graph settles, `failure.json` for the most
-* recent throw, and refusal of a settled directory before any compute — and runs the graph through
-* `runGraph`'s own path, so the root node is a `supervise()` root and a restarted process resumes
-* the graph from its spawn journal. `result.json` holds the graph's supervised result, the same
-* record every supervised run leaves; the edge ledger is the journal's `edge` events and the
-* returned `result.ledger`. Version chains and forks are `supervisePursuit` features and are not
-* offered here. An explicit `reopen` uses the same archived-settle and resume contract as
-* `supervisePursuit`; ordinary re-entry of a settled graph stays refused.
+* Graph twin of `supervisePursuit`, using its directory lifecycle and `runGraph` execution.
+* The directory run id binds the supervised root; spawn-journal edge events own the ledger.
+* Explicit `reopen` archives the result and resumes this id; ordinary settled re-entry refuses.
+* Forks and version chains are offered by `supervisePursuit` only.
 */
 async function superviseGraphPursuit(graph, opts) {
 	assertPursuitDirectory(opts, "superviseGraphPursuit");
@@ -1665,31 +1510,15 @@ async function superviseGraphPursuit(graph, opts) {
 		steerDir,
 		retainedAtSettlement: "release",
 		hooks
-	}), brain), (result) => result.result, reopen === void 0 ? void 0 : (observer) => reopenSettledRun({
-		runDir: opts.runDir.trim(),
-		runId: opts.runId ?? "supervise",
-		reopen,
-		journal: opts.journal,
-		limits: {
-			budget: graph.budget,
-			...opts.reservationPolicy === void 0 ? {} : { reservationPolicy: opts.reservationPolicy }
-		},
-		observer,
-		pursuitId: opts.pursuitId.trim(),
-		now: opts.now ?? Date.now
-	}));
+	}), brain), (result) => result.result, graph.budget);
 }
 /** The pursuit identity and run directory both durable entries require. */
 function assertPursuitDirectory(opts, entry) {
 	for (const field of ["pursuitId", "runDir"]) if (opts[field].trim().length === 0) throw new TypeError(`${entry}: ${field} must be non-empty`);
 	if (opts.retainedAtSettlement === "keep") throw new TypeError(`${entry}: retainedAtSettlement 'keep' cannot hold, because a settled pursuit is never re-entered`);
 }
-/**
-* The run directory's lifecycle around one execution: lock, settled-directory refusal, observer
-* journal, failure record and settle record. `execute` receives the observer-composed hooks and
-* the steer directory the run's control plane uses; `settled` names the value `result.json` holds.
-*/
-async function runDurablePursuit(opts, execute, settled, reopen) {
+/** Own the directory lock, terminal records and observer lifecycle for both pursuit entries. */
+async function runDurablePursuit(opts, execute, settled, budget) {
 	const pursuitId = opts.pursuitId.trim();
 	const runDir = opts.runDir.trim();
 	const observerPath = resolve(runDir, "observer.jsonl");
@@ -1703,12 +1532,26 @@ async function runDurablePursuit(opts, execute, settled, reopen) {
 		let terminalState = "failed";
 		try {
 			const observer = createFileObserverHooks(observerPath, pursuitId);
-			if (reopen !== void 0) await reopen(observer.journal);
+			if (opts.reopen !== void 0) await reopenSettledRun({
+				runDir,
+				runId,
+				reopen: opts.reopen,
+				journal: opts.journal,
+				limits: {
+					budget,
+					...opts.reservationPolicy === void 0 ? {} : { reservationPolicy: opts.reservationPolicy }
+				},
+				observer: observer.journal,
+				pursuitId,
+				now
+			});
 			else {
 				const prior = await readSettleRecord(runDir);
 				if (prior !== void 0) throw new SettledRunDirectoryError(settlePath, prior.tree.root, runId);
 			}
-			await observer.journal.appendEvent(rootEvent(pursuitId, runId, "before", now()));
+			const root = (await (opts.journal ?? new FileSpawnJournal(resolve(runDir, "spawn-journal.jsonl"))).loadTree(runId) ?? []).find((event) => event.kind === "spawned" && event.id === runId);
+			const prior = root?.kind === "spawned" && root.identity ? await new FileCoordinationLog(resolve(runDir, "coordination-log.jsonl")).load(runId, rootCoordinationOwner(root.identity)) : void 0;
+			await observer.journal.appendEvent(rootEvent(pursuitId, runId, "before", now(), { coordinationOffset: prior?.records.length ?? 0 }));
 			delivery = opts.observerDelivery === void 0 ? void 0 : startPursuitObserverDelivery(opts.observerDelivery, async () => projectPursuit(await observer.journal.read()));
 			let result;
 			try {
@@ -1739,7 +1582,7 @@ async function runDurablePursuit(opts, execute, settled, reopen) {
 						pursuitId,
 						at: new Date(now()).toISOString(),
 						error: {
-							name: errorName(error),
+							name: error instanceof Error ? error.name : "NonError",
 							message: errorMessage(error)
 						},
 						...rootStream === void 0 ? {} : { rootStream }
@@ -1786,9 +1629,6 @@ function rootEvent(pursuitId, runId, phase, timestamp, payload) {
 		...payload ? { payload: Object.freeze({ ...payload }) } : {}
 	});
 }
-function errorName(error) {
-	return error instanceof Error ? error.name : "NonError";
-}
 export { FileObserverJournal, RUN_FORK_CORRELATION_KEYS, RunDirectoryLockedError, RunParkedError, SettledRunDirectoryError, SupervisePursuitError, acquireRunDirectoryLock, assertPursuitVersions, deriveExecutionId, discoverDurableSupervisionRun, durableRunToolSpans, handleChatTurn, observerRecordDigest, projectPursuit, readFailureRecord, readRootStream, readRootStreamReceipt, readRunDirectoryLock, readRunParking, readSettleRecord, runDirectoryHolderIsLive, superviseGraphPursuit, supervisePursuit };
 
 //# sourceMappingURL=durable.js.map