@tangle-network/agent-runtime 0.171.0 → 0.173.0

package/dist/{supervisor-B-mmmiOU.js → supervisor-cAFpYJWF.js}

@@ -13,7 +13,7 @@ import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { basename, delimiter, dirname, isAbsolute, join, resolve, sep, win32 } from "node:path";
 import { applyWorkspacePlan, hashWorkspacePlan, materializeProfile, resolveAgentProfileResources } from "@tangle-network/agent-profile-materialize";
-import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, realpath, rm, symlink, writeFile } from "node:fs/promises";
+import { access, chmod, copyFile, mkdir, mkdtemp, open, readFile, realpath, rm, rmdir, stat, symlink, writeFile } from "node:fs/promises";
 import { appendFileSync, constants, createReadStream } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir, tmpdir } from "node:os";
@@ -1814,32 +1814,22 @@ async function runWorktreeHarness(opts) {
 		...opts.runGit ? { runGit: opts.runGit } : {}
 	});
 	try {
-		const applied = applyWorkspacePlan(plan, worktree.path, { existingFiles: "reject" });
-		if (applied.unsupported.length > 0) throw new Error("runWorktreeHarness: applied profile unexpectedly retained unsupported rows");
-		const invocationProfile = profileWithResourceInstructions(profile, resourceInstructions);
-		const { command, args } = harnessInvocation(opts.harness, invocationProfile, opts.taskPrompt, {
-			dangerouslySkipPermissions: true,
-			...opts.codexReproducible ? { codexReproducible: true } : {}
-		});
-		const harnessResult = await runHarness({
+		const applied = applyProfilePlan(plan, worktree.path, "runWorktreeHarness");
+		const harnessResult = await spawnProfiledHarness({
+			workspacePath: worktree.path,
+			profile,
 			harness: opts.harness,
-			cwd: worktree.path,
 			taskPrompt: opts.taskPrompt,
-			invocation: {
-				command,
-				args: [...args, ...applied.flags.map(publicPlanString)]
-			},
-			env: {
-				...process.env,
-				...resolvePublicPlanEnv(applied.env)
-			},
+			applied,
+			resourceInstructions,
+			dangerouslySkipPermissions: true,
 			...opts.codexReproducible ? { codexReproducible: true } : {},
 			...opts.codexReadDeniedPaths ? { codexReadDeniedPaths: opts.codexReadDeniedPaths } : {},
-			...opts.harnessTimeoutMs !== void 0 ? { timeoutMs: opts.harnessTimeoutMs } : {},
-			...opts.signal ? { signal: opts.signal } : {}
+			...opts.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: opts.harnessTimeoutMs } : {},
+			...opts.signal ? { signal: opts.signal } : {},
+			runHarness,
+			context: "runWorktreeHarness"
 		});
-		if (harnessResult.aborted || opts.signal?.aborted) throw new Error("runWorktreeHarness: harness was cancelled by the caller", { cause: opts.signal?.reason });
-		opts.signal?.throwIfAborted();
 		const diff = await captureWorktreeDiff({
 			worktree,
 			excludePaths: applied.written,
@@ -1863,28 +1853,7 @@ async function runWorktreeHarness(opts) {
 				patch: diff.patch,
 				stats: diff.stats,
 				profileMaterialization: profileMaterializationReceipt(applied, resourceInstructions),
-				harness: {
-					name: opts.harness,
-					exitCode: harnessResult.exitCode,
-					timedOut: harnessResult.timedOut,
-					killedBySignal: harnessResult.killedBySignal,
-					durationMs: harnessResult.durationMs,
-					stdout: harnessResult.stdout,
-					stderr: harnessResult.stderr,
-					...harnessResult.usage ? { usage: harnessResult.usage } : {},
-					...harnessResult.evidence ? {
-						cliVersion: harnessResult.evidence.cliVersion,
-						executableSha256: harnessResult.evidence.executableSha256,
-						requestedPromptSha256: harnessResult.evidence.requestedPromptSha256,
-						effectivePromptSha256: harnessResult.evidence.effectivePromptSha256,
-						nonPromptArgsSha256: harnessResult.evidence.nonPromptArgsSha256,
-						controlledConfigSha256: harnessResult.evidence.controlledConfigSha256,
-						readDeniedPaths: [...harnessResult.evidence.readDeniedPaths],
-						readDeniedPathsSha256: harnessResult.evidence.readDeniedPathsSha256,
-						readDeniedPathCount: harnessResult.evidence.readDeniedPathCount,
-						executionPolicy: harnessResult.evidence.policy
-					} : {}
-				},
+				harness: harnessRunRecord(opts.harness, harnessResult),
 				...checks ? { checks } : {}
 			},
 			cleanup
@@ -1898,6 +1867,54 @@ async function runWorktreeHarness(opts) {
 		throw err;
 	}
 }
+/**
+* Run the one worktree-harness operation against a workspace the CALLER supplies, so the harness
+* edits that exact directory and its edits stay there after the call.
+*
+* The profile inputs this path materializes are removed again before it returns, whether the run
+* succeeded, threw, or was cancelled. That is what keeps the invariant a caller reads the directory
+* for: after the call the workspace holds the harness's own edits and nothing else, so a
+* `git status` over it answers "did the author change anything" and not "did Runtime write a
+* settings file". A harness edit to a materialized input is removed with it, exactly as
+* `runWorktreeHarness` excludes those paths from its captured patch.
+*
+* The workspace is NOT created, cleaned, or removed here: its lifecycle belongs to the caller,
+* which is the whole point of the placement.
+*/
+async function runInPlaceHarness(opts) {
+	opts.signal?.throwIfAborted();
+	const runHarness = opts.runHarness ?? runLocalHarness;
+	if (!opts.workspacePath) throw new Error("runInPlaceHarness: workspacePath required");
+	assertSupportedWorktreeProfile(opts.profile, opts.harness);
+	assertSafeProfileResourcePaths(opts.profile);
+	const profile = await resolveAgentProfileResources(opts.profile, resourceResolutionOptions(opts.resourceResolution, opts.signal));
+	opts.signal?.throwIfAborted();
+	const { plan, resourceInstructions } = prepareWorktreeProfile(profile, opts.harness);
+	if (!(await stat(opts.workspacePath).catch(() => void 0))?.isDirectory()) throw new Error(`runInPlaceHarness: workspacePath is not an existing directory: ${opts.workspacePath}`);
+	const applied = applyProfilePlan(plan, opts.workspacePath, "runInPlaceHarness");
+	try {
+		const harnessResult = await spawnProfiledHarness({
+			workspacePath: opts.workspacePath,
+			profile,
+			harness: opts.harness,
+			taskPrompt: opts.taskPrompt,
+			applied,
+			resourceInstructions,
+			dangerouslySkipPermissions: true,
+			...opts.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: opts.harnessTimeoutMs } : {},
+			...opts.signal ? { signal: opts.signal } : {},
+			runHarness,
+			context: "runInPlaceHarness"
+		});
+		return {
+			workspacePath: opts.workspacePath,
+			profileMaterialization: profileMaterializationReceipt(applied, resourceInstructions),
+			harness: harnessRunRecord(opts.harness, harnessResult)
+		};
+	} finally {
+		await removeAppliedPlanFiles(opts.workspacePath, applied.written);
+	}
+}
 /** Compute the same plan identity `runWorktreeHarness` consumes, with no repository or process IO. */
 function worktreeProfileExecutionPlan(profile, harness) {
 	const { plan, resourceInstructions } = prepareWorktreeProfile(profile, harness);
@@ -1907,6 +1924,93 @@ function worktreeProfileExecutionPlan(profile, harness) {
 		resourceInstructions: resourceInstructionReceipt(resourceInstructions)
 	});
 }
+/** Write the profile inputs into a workspace. A plan that could not be fully expressed, or whose
+*  path is already occupied, fails here — before any external process starts. */
+function applyProfilePlan(plan, workspacePath, context) {
+	const applied = applyWorkspacePlan(plan, workspacePath, { existingFiles: "reject" });
+	if (applied.unsupported.length > 0) throw new Error(`${context}: applied profile unexpectedly retained unsupported rows`);
+	return applied;
+}
+/**
+* The ONE profile-to-process step both placements share: §1.5 prompt/model delivery through
+* `harnessInvocation`, the materializer's flags and environment, and the `runLocalHarness` spawn
+* in `workspacePath`. Neither placement re-derives argv, so a harness capability added to the
+* invocation table reaches both.
+*/
+async function spawnProfiledHarness(args) {
+	const invocationProfile = profileWithResourceInstructions(args.profile, args.resourceInstructions);
+	const { command, args: invocationArgs } = harnessInvocation(args.harness, invocationProfile, args.taskPrompt, {
+		dangerouslySkipPermissions: args.dangerouslySkipPermissions,
+		...args.codexReproducible ? { codexReproducible: true } : {}
+	});
+	const harnessResult = await args.runHarness({
+		harness: args.harness,
+		cwd: args.workspacePath,
+		taskPrompt: args.taskPrompt,
+		invocation: {
+			command,
+			args: [...invocationArgs, ...args.applied.flags.map(publicPlanString)]
+		},
+		env: {
+			...process.env,
+			...resolvePublicPlanEnv(args.applied.env)
+		},
+		...args.codexReproducible ? { codexReproducible: true } : {},
+		...args.codexReadDeniedPaths ? { codexReadDeniedPaths: args.codexReadDeniedPaths } : {},
+		...args.harnessTimeoutMs !== void 0 ? { timeoutMs: args.harnessTimeoutMs } : {},
+		...args.signal ? { signal: args.signal } : {}
+	});
+	if (harnessResult.aborted || args.signal?.aborted) throw new Error(`${args.context}: harness was cancelled by the caller`, { cause: args.signal?.reason });
+	args.signal?.throwIfAborted();
+	return harnessResult;
+}
+/** Project one `LocalHarnessResult` onto the harness record both placements report. */
+function harnessRunRecord(name, harnessResult) {
+	return {
+		name,
+		exitCode: harnessResult.exitCode,
+		timedOut: harnessResult.timedOut,
+		killedBySignal: harnessResult.killedBySignal,
+		durationMs: harnessResult.durationMs,
+		stdout: harnessResult.stdout,
+		stderr: harnessResult.stderr,
+		...harnessResult.usage ? { usage: harnessResult.usage } : {},
+		...harnessResult.evidence ? {
+			cliVersion: harnessResult.evidence.cliVersion,
+			executableSha256: harnessResult.evidence.executableSha256,
+			requestedPromptSha256: harnessResult.evidence.requestedPromptSha256,
+			effectivePromptSha256: harnessResult.evidence.effectivePromptSha256,
+			nonPromptArgsSha256: harnessResult.evidence.nonPromptArgsSha256,
+			controlledConfigSha256: harnessResult.evidence.controlledConfigSha256,
+			readDeniedPaths: [...harnessResult.evidence.readDeniedPaths],
+			readDeniedPathsSha256: harnessResult.evidence.readDeniedPathsSha256,
+			readDeniedPathCount: harnessResult.evidence.readDeniedPathCount,
+			executionPolicy: harnessResult.evidence.policy
+		} : {}
+	};
+}
+/** Remove the profile inputs written into a caller-owned workspace, plus the directories that
+*  application created and this removal empties. A file the harness deleted itself is already
+*  gone, and a directory that still holds anything is left alone. */
+async function removeAppliedPlanFiles(workspacePath, written) {
+	const root = resolve(workspacePath);
+	const prunable = /* @__PURE__ */ new Set();
+	for (const relPath of written) {
+		const absolute = resolve(root, relPath);
+		await rm(absolute, { force: true });
+		let parent = dirname(absolute);
+		while (parent.length > root.length && parent.startsWith(`${root}/`)) {
+			prunable.add(parent);
+			parent = dirname(parent);
+		}
+	}
+	for (const directory of [...prunable].sort((a, b) => b.length - a.length)) try {
+		await rmdir(directory);
+	} catch (error) {
+		const code = error.code;
+		if (code !== "ENOTEMPTY" && code !== "ENOENT" && code !== "EEXIST") throw error;
+	}
+}
 function prepareWorktreeProfile(profile, harness) {
 	const resourceInstructions = resolveResourceInstructions(profile);
 	const workspaceProfile = materializationOnlyProfile(profile);
@@ -5345,6 +5449,178 @@ function priceUnreceiptedWork(work) {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/task-prompt.ts
+/**
+*
+* The one rule for reading a leaf task as prompt text. A `Scope` task is opaque (`unknown`) and
+* every leaf that speaks to a text-in/text-out backend has to project it the same way, or two
+* placements handed the identical task send the harness different bytes.
+*
+* Module-scoped, not package surface: it is shared between sibling leaf executors, never a
+* published verb.
+*/
+/** A leaf task is opaque (`unknown`). A string is the prompt verbatim; an object
+*  with a `prompt`/`content`/`task` string field uses it; otherwise it serializes. */
+function taskToPrompt(task) {
+	if (typeof task === "string") return task;
+	if (task && typeof task === "object") {
+		const obj = task;
+		for (const k of [
+			"prompt",
+			"content",
+			"task",
+			"message"
+		]) if (typeof obj[k] === "string") return obj[k];
+		if (Array.isArray(obj.parts)) {
+			const parsed = AgentTurnInputSchema.safeParse({ parts: obj.parts });
+			if (parsed.success && parsed.data.parts) return renderInputPartsAsText(parsed.data.parts);
+		}
+	}
+	return JSON.stringify(task);
+}
+//#endregion
+//#region src/runtime/supervise/in-place-cli-executor.ts
+/**
+*
+* The in-place CLI leaf executor — a supervisor-authored `AgentProfile` driving a local
+* coding-harness CLI (claude-code / codex / opencode / pi) on a workspace the CALLER supplies,
+* surfaced as the open `Executor<Out>` port (`./types`).
+*
+* The difference from `createWorktreeCliExecutor` is the whole point of it: that leaf cuts a git
+* worktree of its own and hands back the diff, so the directory it was pointed at is never edited;
+* this leaf runs the harness in the directory it was given, so the edits ARE that directory and
+* they are still there when the call returns. That is what a caller needs when the workspace has
+* to survive between calls — a multi-shot author that resumes on top of its own edits, or a
+* candidate directory the caller commits itself.
+*
+* Both leaves share one physical act (`runInPlaceHarness` / `runWorktreeHarness`, both in
+* `../../mcp/worktree-harness`): the same profile materializer, the same `harnessInvocation`
+* mapper, the same subprocess spawn. Only workspace ownership differs.
+*
+* The profile inputs this path materializes are removed before it returns, so the workspace the
+* caller reads holds the harness's own edits and nothing else.
+*
+* Token accounting: a harness CLI run reports no usage receipt, so this leaf is `budgetExempt` and
+* its `Spend` marks `tokensKnown: false` — the `{0,0}` is a floor, never a measured-free run.
+*
+* @experimental
+*/
+/**
+* Build an in-place CLI leaf `Executor`. Per-spawn, but NOT per-workspace: repeated spawns against
+* the same `workspacePath` run in the same directory on purpose, each seeing what the last one
+* wrote.
+*
+* Fail-loud: an empty `workspacePath`, an incomplete/unsupported profile, a separate harness
+* override, or an explicitly empty `taskPrompt` throws at construction. A `workspacePath` that is
+* not an existing directory throws before the harness launches. `resultArtifact()` before
+* `execute()` resolves throws.
+*
+* @experimental
+*/
+function createInPlaceCliExecutor(options) {
+	if (!options.workspacePath) throw new ValidationError("createInPlaceCliExecutor: workspacePath required");
+	if ("harness" in options) throw new ValidationError("createInPlaceCliExecutor: separate harness is forbidden; set AgentProfile.harness");
+	const profile = executableAgentProfileSnapshot(options.profile, "createInPlaceCliExecutor");
+	const harness = localHarnessFromProfile$1(profile);
+	if (options.taskPrompt !== void 0 && (typeof options.taskPrompt !== "string" || options.taskPrompt.length === 0)) throw new ValidationError("createInPlaceCliExecutor: taskPrompt required");
+	const executionId = randomUUID();
+	const attemptId = options.executionAttemptId ?? newExecutionAttemptId(executionId);
+	const controller = new AbortController();
+	let artifact;
+	const profilePlan = worktreeProfileExecutionPlan(profile, harness);
+	const profileModel = concreteProfileModel(profile);
+	if (!profileModel) throw new ValidationError("createInPlaceCliExecutor: exact profile model unexpectedly missing");
+	return attestRuntimeOwnedExecutor({
+		runtime: "cli",
+		budgetExempt: true,
+		async execute(task, signal) {
+			const linked = linkAbort(signal, controller.signal).signal;
+			const started = Date.now();
+			const taskPrompt = executionTaskPrompt$1(task, options.taskPrompt);
+			const result = await runInPlaceHarness({
+				workspacePath: options.workspacePath,
+				profile,
+				harness,
+				taskPrompt,
+				...options.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: options.harnessTimeoutMs } : {},
+				...linked ? { signal: linked } : {},
+				...options.runHarness ? { runHarness: options.runHarness } : {}
+			});
+			const spent = {
+				iterations: 1,
+				tokens: {
+					input: 0,
+					output: 0
+				},
+				tokensKnown: false,
+				usd: 0,
+				ms: Date.now() - started
+			};
+			artifact = {
+				outRef: contentAddress(result),
+				out: result,
+				spent
+			};
+			return artifact;
+		},
+		async teardown(_grace) {
+			controller.abort();
+			return { destroyed: true };
+		},
+		resultArtifact() {
+			if (!artifact) throw new ValidationError("createInPlaceCliExecutor: resultArtifact() read before execute() resolved");
+			return artifact;
+		}
+	}, {
+		effectiveProfile: profile,
+		backend: `cli-in-place:${harness}`,
+		model: {
+			status: "known",
+			id: profileModel
+		},
+		execution: {
+			kind: "in-place-run",
+			id: executionId
+		},
+		materializer: "agent-profile-worktree-plan",
+		plan: {
+			kind: "cli-in-place",
+			profilePlan,
+			harness,
+			harnessTimeoutMs: options.harnessTimeoutMs ?? null
+		}
+	}, {
+		attemptId,
+		binding: {
+			workspacePath: options.workspacePath,
+			executionId,
+			harness,
+			model: profileModel
+		},
+		descriptor: {
+			kind: "in-place-cli-run",
+			transport: "process",
+			backend: harness
+		}
+	});
+}
+function localHarnessFromProfile$1(profile) {
+	const harness = profile.harness;
+	if (LOCAL_HARNESSES.includes(harness)) return harness;
+	throw new ValidationError(`createInPlaceCliExecutor: AgentProfile.harness must select ${LOCAL_HARNESSES.join(", ")}`);
+}
+/** A scoped execution task is authoritative. The configured prompt remains the unambiguous
+*  direct-call default for `execute(undefined, signal)` consumers. */
+function executionTaskPrompt$1(task, configuredPrompt) {
+	if (task === void 0) {
+		if (configuredPrompt !== void 0) return configuredPrompt;
+		throw new ValidationError("createInPlaceCliExecutor: execute task required when taskPrompt is not configured");
+	}
+	const prompt = taskToPrompt(task);
+	if (typeof prompt !== "string" || prompt.length === 0) throw new ValidationError("createInPlaceCliExecutor: execute task produced no prompt text");
+	return prompt;
+}
+//#endregion
 //#region src/runtime/supervise/node-status.ts
 /**
 * Which {@link NodeStatus} values mean the node is finished.
@@ -6505,7 +6781,8 @@ function readPromptOptions(loopCtx) {
 *                     bridge stamps them into the harness child's environment at spawn.
 *   - `router`,
 *     `router-tools`  NO — a direct model HTTP call. There is no worker process to inherit anything.
-*   - `cli-worktree`  NO — the work is dispatched through a local harness transport that exposes
+*   - `cli-worktree`,
+*     `cli-in-place`  NO — the work is dispatched through a local harness transport that exposes
 *                     no environment channel. Wiring it means adding that channel to the transport
 *                     first; until then it is honestly unpropagated.
 *   - `provider`      NO — `AgentEnvironmentProvider` has no environment field on its port.
@@ -6526,6 +6803,7 @@ const WORKER_TRACE_PROPAGATION = {
 	"router-tools": false,
 	bridge: true,
 	"cli-worktree": false,
+	"cli-in-place": false,
 	provider: false
 };
 /**
@@ -6836,6 +7114,7 @@ const bridgeModelBaseUrlHeader = "x-cli-bridge-model-base-url";
 const bridgeProfileMaterializationSchema = "cli-bridge.profile-materialization.v2";
 const bridgeUsageCostSchema = "cli-bridge.usage-cost.v1";
 const cliWorktreeSeamKey = "cli-worktree";
+const cliInPlaceSeamKey = "cli-in-place";
 const providerSeamKey = "provider";
 function isLoopbackBridgeHost(hostname) {
 	const host = hostname.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "");
@@ -9504,6 +9783,26 @@ const cliWorktreeExecutor = (spec, ctx) => {
 		...ctx.node?.attemptId !== void 0 ? { executionAttemptId: ctx.node.attemptId } : {}
 	});
 };
+/**
+* The leaf `createInPlaceCliExecutor` as a backend-as-data factory: a supervisor-authored
+* `AgentProfile` driving a local coding CLI in the workspace the caller supplied, so its edits are
+* still there for the next spawn. `budgetExempt` like the other CLI leaves; the authored
+* systemPrompt + model reach the harness via §1.5.
+*/
+const cliInPlaceExecutor = (spec, ctx) => {
+	const seam = readSeam(ctx, cliInPlaceSeamKey, "cli-in-place");
+	if (!seam.workspacePath) throw new ValidationError("cliInPlaceExecutor: CliInPlaceSeam.workspacePath required");
+	const effectiveProfile = agentProfileSchema.parse(spec.profile);
+	assertExecutableAgentProfile(effectiveProfile, "cliInPlaceExecutor");
+	return createInPlaceCliExecutor({
+		workspacePath: seam.workspacePath,
+		profile: effectiveProfile,
+		...seam.taskPrompt !== void 0 ? { taskPrompt: seam.taskPrompt } : {},
+		...seam.harnessTimeoutMs !== void 0 ? { harnessTimeoutMs: seam.harnessTimeoutMs } : {},
+		...seam.runHarness ? { runHarness: seam.runHarness } : {},
+		...ctx.node?.attemptId !== void 0 ? { executionAttemptId: ctx.node.attemptId } : {}
+	});
+};
 function assertExactConfigKeys(value, allowed, context) {
 	const unknown = Object.keys(value).filter((key) => !allowed.has(key));
 	if (unknown.length > 0) throw new ValidationError(`${context}: unknown fields ${unknown.sort().join(", ")}; execution behavior belongs in AgentProfile`);
@@ -9549,6 +9848,21 @@ function snapshotExecutorConfig(config) {
 				...runCommand === void 0 ? {} : { runCommand }
 			});
 		}
+		case "cli-in-place": {
+			assertExactConfigKeys(config, /* @__PURE__ */ new Set([
+				"backend",
+				"harnessTimeoutMs",
+				"runHarness",
+				"taskPrompt",
+				"workspacePath"
+			]), "createExecutor cli-in-place config");
+			const { runHarness, ...decisionData } = config;
+			const snapshot = detachedSnapshot(decisionData, "createExecutor cli-in-place config");
+			return Object.freeze({
+				...snapshot,
+				...runHarness === void 0 ? {} : { runHarness }
+			});
+		}
 		case "provider": {
 			const { provider, registry, profileForCreate, taskToTurn, ...decisionData } = config;
 			const snapshot = detachedSnapshot(decisionData, "createExecutor provider config");
@@ -9653,6 +9967,7 @@ function bindReusableExecutorExecutionId(captured, executionId) {
 		case "router":
 		case "router-tools":
 		case "cli":
+		case "cli-in-place":
 		case "provider":
 		case "sandbox": return captured;
 	}
@@ -9684,6 +9999,7 @@ function createExecutor(config) {
 			case "bridge": return bridgeExecutor(spec, seamed);
 			case "cli": return cliExecutor(spec, seamed);
 			case "cli-worktree": return cliWorktreeExecutor(spec, seamed);
+			case "cli-in-place": return cliInPlaceExecutor(spec, seamed);
 			case "provider": {
 				const providerSeam = readSeam(seamed, providerSeamKey, "provider");
 				const provider = resolveAgentEnvironmentProvider(providerSeam.provider, providerSeam.registry);
@@ -9827,27 +10143,6 @@ function readOptionalMcpAttachments(ctx, key, who) {
 	if (entries === void 0 || entries.length === 0 || entries.some(([, server]) => server === null || typeof server !== "object")) throw new ValidationError(`${who} executor: seam ${JSON.stringify(key)} must be a non-empty map of MCP servers`);
 	return value;
 }
-/** A leaf task is opaque (`unknown`). A string is the prompt verbatim; an object
-*  with a `prompt`/`content`/`task` string field uses it; otherwise it serializes.
-*  Module-exported (not package surface) so sibling leaf executors read a task
-*  identically instead of re-deriving the rule. */
-function taskToPrompt(task) {
-	if (typeof task === "string") return task;
-	if (task && typeof task === "object") {
-		const obj = task;
-		for (const k of [
-			"prompt",
-			"content",
-			"task",
-			"message"
-		]) if (typeof obj[k] === "string") return obj[k];
-		if (Array.isArray(obj.parts)) {
-			const parsed = AgentTurnInputSchema.safeParse({ parts: obj.parts });
-			if (parsed.success && parsed.data.parts) return renderInputPartsAsText(parsed.data.parts);
-		}
-	}
-	return JSON.stringify(task);
-}
 /** Validate and render every AgentProfile axis the direct Router path claims to carry.
 * Unsupported behavioral axes fail before the HTTP request; inline resources become
 * named system-prompt attachments because this executor has no workspace to mount. */
@@ -9991,8 +10286,8 @@ function singleShotDriver(maxIterations) {
 * it trusts a reported `input`: the token channel is an accounting unit, not a trust boundary
 * against a provider that misreports its own usage.
 *
-* Pure and deterministic: `now()` is injected, there is no I/O, and no wall-clock or
-* RNG read. A `reserve`/`reconcile` ticket is single-use (fail-loud on double or
+* Pure and deterministic: the run's start instant is supplied, there is no I/O, and no
+* wall-clock or RNG read. A `reserve`/`reconcile` ticket is single-use (fail-loud on double or
 * unknown reconcile) so a child can never refund twice. Reconciling an OPEN ticket always
 * closes it: a fail-loud condition settles the reservation first and throws afterwards, so no
 * error path can strand a reservation past the join barrier's `assertNoOpenTickets`.
@@ -10113,15 +10408,16 @@ async function foldUsage(events) {
 	return spendFromUsageTotals(totals);
 }
 /**
-* Create a conserved reservation pool from a root `Budget`. `now()` is injected so the
-* deadline readout is deterministic; defaults to `Date.now` for non-test callers. The
-* absolute deadline for a fresh pool is fixed at construction (`now() + budget.deadlineMs`). A
-* restored pool instead retains `restore.absoluteDeadlineMs`, so restart never slides the original
-* wall-clock limit. The readout is an absolute instant, not a shrinking remainder.
+* Create a conserved reservation pool from a root `Budget`. `runStartedAtMs` is the WALL-CLOCK
+* instant the run's root was recorded, and it is the only input the deadline is derived from:
+* `runStartedAtMs + root.deadlineMs`, or `0` when the root declares no deadline. The pool holds no
+* clock, so a caller cannot hand it a run-relative one and get a duration back where an instant is
+* expected. A resumed pool passes the ORIGINAL root instant, so restart never slides the limit.
+* The readout is an absolute instant, not a shrinking remainder.
 */
-function createBudgetPool(root, now = Date.now, restore = {}) {
+function createBudgetPool(root, runStartedAtMs, restore = {}) {
 	assertValidBudget(root, "root budget");
-	if (restore.absoluteDeadlineMs !== void 0 && (!Number.isFinite(restore.absoluteDeadlineMs) || restore.absoluteDeadlineMs < 0)) throw new Error("budget restore.absoluteDeadlineMs must be a non-negative finite number");
+	if (!Number.isFinite(runStartedAtMs) || runStartedAtMs < 0) throw new Error("budget runStartedAtMs must be a non-negative finite number");
 	let freeTokens = root.maxTokens;
 	let reservedTokens = 0;
 	let committedTokens = 0;
@@ -10136,7 +10432,7 @@ function createBudgetPool(root, now = Date.now, restore = {}) {
 	let freeIterations = root.maxIterations;
 	let reservedIterations = 0;
 	let committedIterations = 0;
-	const absoluteDeadlineMs = restore.absoluteDeadlineMs ?? (root.deadlineMs !== void 0 ? now() + root.deadlineMs : 0);
+	const absoluteDeadlineMs = root.deadlineMs === void 0 ? 0 : runStartedAtMs + root.deadlineMs;
 	let nextTicketId = 0;
 	const open = /* @__PURE__ */ new Set();
 	function reserve(b) {
@@ -10753,14 +11049,15 @@ function makeNestedScopeSeam(args, liveWorkerCapacity, childNodeId, childBudget,
 		...args.maxDepth !== void 0 ? { maxDepth: args.maxDepth } : {},
 		journalRoot: args.root,
 		mount(nestedRoot, signal) {
-			const deadlineMs = childDeadlineAtMs === void 0 ? void 0 : Math.max(0, childDeadlineAtMs - now());
+			const mountedAtMs = now();
+			const deadlineMs = childDeadlineAtMs === void 0 ? void 0 : Math.max(0, childDeadlineAtMs - mountedAtMs);
 			return createScope({
 				parentId: childNodeId,
 				root: nestedRoot,
 				pool: createBudgetPool({
 					...childBudget,
 					...deadlineMs !== void 0 ? { deadlineMs } : {}
-				}, now),
+				}, mountedAtMs),
 				journal: args.journal,
 				blobs: args.blobs,
 				executors: args.executors,
@@ -12798,9 +13095,6 @@ function rootStartedAtMs(root) {
 	if (!Number.isFinite(startedAt)) throw new RuntimeRunStateError(`supervisor: root event for '${root.id}' has an invalid timestamp '${root.at}'`);
 	return startedAt;
 }
-function rootDeadline(root) {
-	return rootStartedAtMs(root) + (root.budget.deadlineMs ?? 0);
-}
 /** Child reservations whose spawn was durable but whose terminal record never landed. */
 function uncertainSpawnBudgets(events) {
 	const terminal = new Set(events.filter(closesCursorSlot).map((event) => event.id));
@@ -12889,14 +13183,12 @@ function createSupervisor() {
 			let pool;
 			let runEpochMs = runStartedAtMs;
 			if (resuming) {
-				const rootEvent = assertResumeContract(prior, opts);
-				runEpochMs = rootStartedAtMs(rootEvent);
+				runEpochMs = rootStartedAtMs(assertResumeContract(prior, opts));
 				const measured = sumMeasuredSpendFromEvents(prior);
 				const uncertainReservations = uncertainSpawnBudgets(prior);
-				pool = createBudgetPool(opts.budget, now, {
+				pool = createBudgetPool(opts.budget, runEpochMs, {
 					committed: addSpend(measured.childWork, measured.driverInference),
-					uncertainReservations,
-					...rootEvent.budget.deadlineMs !== void 0 ? { absoluteDeadlineMs: rootDeadline(rootEvent) } : {}
+					uncertainReservations
 				});
 				const settled = await replaySpawnTree(opts.journal, opts.blobs, opts.runId);
 				resumeFrom = {
@@ -12910,7 +13202,7 @@ function createSupervisor() {
 					priorSpend: sumSpendFromEvents(prior)
 				};
 			} else {
-				pool = createBudgetPool(opts.budget, now, { ...opts.budget.deadlineMs !== void 0 ? { absoluteDeadlineMs: runStartedAtMs + opts.budget.deadlineMs } : {} });
+				pool = createBudgetPool(opts.budget, runStartedAtMs);
 				await opts.journal.beginTree(opts.runId, runStartedAt);
 				const rootReceipt = rootMaterializationReceipt(opts);
 				const rootRuntime = opts.rootMaterialization?.runtime ?? "inline";
@@ -13411,6 +13703,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 //#endregion
-export { createPushTraceSource as $, createWorktree as $t, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as A, readTraceContextFromEnv as At, captureReusableExecutorConfig as B, generateSpanId as Bt, timerAt as C, acquireSandbox as Ct, freeSlots as D, observedModelMatchesDeclared as Dt, effectiveConcurrency as E, canonicalObservedModel as Et, bindReusableExecutorExecutionId as F, buildRuntimeEventOtelSpans as Ft, createWorktreeCliExecutor as G, createRuntimeEventCollector as Gt, createExecutor as H, padSpanId as Ht, bridgeAdmissionRead as I, createOpenInferenceFileExporter as It, workerTraceEnv as J, sanitizeKnowledgeReadinessReport as Jt, WORKER_TRACE_PROPAGATION as K, createRuntimeStreamEventCollector as Kt, bridgeModelRouteRefusal as L, createOtelExporter as Lt, assertValidBudget as M, INTELLIGENCE_WIRE_VERSION as Mt, createBudgetPool as N, buildLoopOtelSpans as Nt, queueOf as O, createPropagatingTraceEmitter as Ot, spendFromUsageEvents as P, buildLoopSpanNodes as Pt, createSteerableSandboxSession as Q, captureWorktreeDiff as Qt, bridgeRuntimeAttachmentsKey as R, exportEvalRuns as Rt, pollFor as S, worktreeCliProfileMaterialization as Sn, probeSandboxCapabilities as St, waitUntil as T, runBrainLoop as Tt, createExecutorRegistry as U, padTraceId as Ut, cliWorktreeExecutor as V, loopEventToOtelSpan as Vt, snapshotExecutorConfig as W, toOtelAttributes as Wt, workerTraceSeamKey as X, runSettledCommand as Xt, workerTraceHeaders as Y, sanitizeRuntimeStreamEvent as Yt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Z, runWorktreeHarness as Zt, recordScopeOwnerMaterialization as _, renderProfileMaterializationIssues as _n, createSandboxForSpec as _t, uncertainSpawnBudgets as a, parseCodexTokenUsage as an, createInbox as at, createWaitProbes as b, unsupportedProfileDimensions as bn, runAgentRounds as bt, pickBestDelivered as c, assertProfileMaterialization as cn, PEER_MAIL_WIRE_KEY as ct, driverChild as d, fullProfileMaterialization as dn, isPeerMailEnvelope as dt, removeWorktree as en, decodeToolPart as et, withDriverExecutor as f, profileMaterializationAxes$1 as fn, peerMailTools as ft, meterRuntimeOwnedProviderAttempt as g, promptResourceProfileMaterialization as gn, TERMINAL_DECISIONS as gt, meterRuntimeOwnedAccounting as h, promptOnlyProfileMaterialization as hn, isTerminalNodeStatus as ht, sumMeasuredSpendFromEvents as i, localHarnessExecutable as in, readWorkerProgress as it, teardownExecutor as j, traceContextToEnv as jt, rollingDispatch as k, mergeTraceEnv as kt, runFinalizer as l, controlProfileMaterialization as ln, claimsAuthority as lt, deriveNodeExecutionIdentity as m, promptModelProfileMaterialization as mn, isLiveNodeStatus as mt, createSupervisor as n, LOCAL_HARNESSES as nn, DEFAULT_STALL_AFTER_MS as nt, bestDelivered as o, CodexExecutionDiagnosticError as on, AUTHORITY_MARKERS as ot, createScope as p, promptControlProfileMaterialization as pn, peerMailVerbNames as pt, readWorkerTraceContext as q, sanitizeAgentRuntimeEvent as qt, maxSeqOf as r, harnessSupportsReasoningEffort as rn, createActivityLog as rt, collectDelivered as s, AGENT_PROFILE_MATERIALIZATION_AXES as sn, DEFAULT_PEER_MAIL_LIMITS as st, createRootHandle as t, DEFAULT_LOCAL_HARNESS as tn, sandboxSessionTraceSource as tt, runTree as u, defineProfileMaterializationContract as un, createPeerMailbox as ut, scopeOwnerExecutorNodeContext as v, renderUnsupported as vn, defaultSelectWinner as vt, validateWaitSpec as w, routerBrain as wt, isWaitOutcome as x, validateProfileMaterialization as xn, createSandboxLineage as xt, settledToIteration as y, sandboxActProfileMaterialization as yn, isTerminalDecision as yt, bridgeStopSignalKey as z, flatOtelSpan as zt };
+export { createSteerableSandboxSession as $, runWorktreeHarness as $t, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as A, createPropagatingTraceEmitter as At, captureReusableExecutorConfig as B, exportEvalRuns as Bt, timerAt as C, validateProfileMaterialization as Cn, createSandboxLineage as Ct, freeSlots as D, runBrainLoop as Dt, effectiveConcurrency as E, routerBrain as Et, bindReusableExecutorExecutionId as F, buildLoopOtelSpans as Ft, snapshotExecutorConfig as G, padTraceId as Gt, cliWorktreeExecutor as H, generateSpanId as Ht, bridgeAdmissionRead as I, buildLoopSpanNodes as It, readWorkerTraceContext as J, createRuntimeStreamEventCollector as Jt, createWorktreeCliExecutor as K, toOtelAttributes as Kt, bridgeModelRouteRefusal as L, buildRuntimeEventOtelSpans as Lt, assertValidBudget as M, readTraceContextFromEnv as Mt, createBudgetPool as N, traceContextToEnv as Nt, queueOf as O, canonicalObservedModel as Ot, spendFromUsageEvents as P, INTELLIGENCE_WIRE_VERSION as Pt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Q, runSettledCommand as Qt, bridgeRuntimeAttachmentsKey as R, createOpenInferenceFileExporter as Rt, pollFor as S, unsupportedProfileDimensions as Sn, runAgentRounds as St, waitUntil as T, acquireSandbox as Tt, createExecutor as U, loopEventToOtelSpan as Ut, cliInPlaceExecutor as V, flatOtelSpan as Vt, createExecutorRegistry as W, padSpanId as Wt, workerTraceHeaders as X, sanitizeKnowledgeReadinessReport as Xt, workerTraceEnv as Y, sanitizeAgentRuntimeEvent as Yt, workerTraceSeamKey as Z, sanitizeRuntimeStreamEvent as Zt, recordScopeOwnerMaterialization as _, promptOnlyProfileMaterialization as _n, createInPlaceCliExecutor as _t, uncertainSpawnBudgets as a, harnessSupportsReasoningEffort as an, readWorkerProgress as at, createWaitProbes as b, renderUnsupported as bn, defaultSelectWinner as bt, pickBestDelivered as c, CodexExecutionDiagnosticError as cn, DEFAULT_PEER_MAIL_LIMITS as ct, driverChild as d, controlProfileMaterialization as dn, createPeerMailbox as dt, captureWorktreeDiff as en, createPushTraceSource as et, withDriverExecutor as f, defineProfileMaterializationContract as fn, isPeerMailEnvelope as ft, meterRuntimeOwnedProviderAttempt as g, promptModelProfileMaterialization as gn, isTerminalNodeStatus as gt, meterRuntimeOwnedAccounting as h, promptControlProfileMaterialization as hn, isLiveNodeStatus as ht, sumMeasuredSpendFromEvents as i, LOCAL_HARNESSES as in, createActivityLog as it, teardownExecutor as j, mergeTraceEnv as jt, rollingDispatch as k, observedModelMatchesDeclared as kt, runFinalizer as l, AGENT_PROFILE_MATERIALIZATION_AXES as ln, PEER_MAIL_WIRE_KEY as lt, deriveNodeExecutionIdentity as m, profileMaterializationAxes$1 as mn, peerMailVerbNames as mt, createSupervisor as n, removeWorktree as nn, sandboxSessionTraceSource as nt, bestDelivered as o, localHarnessExecutable as on, createInbox as ot, createScope as p, fullProfileMaterialization as pn, peerMailTools as pt, WORKER_TRACE_PROPAGATION as q, createRuntimeEventCollector as qt, maxSeqOf as r, DEFAULT_LOCAL_HARNESS as rn, DEFAULT_STALL_AFTER_MS as rt, collectDelivered as s, parseCodexTokenUsage as sn, AUTHORITY_MARKERS as st, createRootHandle as t, createWorktree as tn, decodeToolPart as tt, runTree as u, assertProfileMaterialization as un, claimsAuthority as ut, scopeOwnerExecutorNodeContext as v, promptResourceProfileMaterialization as vn, TERMINAL_DECISIONS as vt, validateWaitSpec as w, worktreeCliProfileMaterialization as wn, probeSandboxCapabilities as wt, isWaitOutcome as x, sandboxActProfileMaterialization as xn, isTerminalDecision as xt, settledToIteration as y, renderProfileMaterializationIssues as yn, createSandboxForSpec as yt, bridgeStopSignalKey as z, createOtelExporter as zt };
 
-//# sourceMappingURL=supervisor-B-mmmiOU.js.map
+//# sourceMappingURL=supervisor-cAFpYJWF.js.map