effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/Subagent-Cy_hU1tv.mjs

@@ -0,0 +1,1469 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "./utf8-DchGZRBd.mjs";
+import { AgentPolicy } from "./core/AgentPolicy.mjs";
+import { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from "./core/Identifiers.mjs";
+import { IdempotencyKey, JoinedToHost, Receipt } from "./core/Receipt.mjs";
+import { IdGenerator as IdGenerator$1 } from "./core/IdGenerator.mjs";
+import { BackgroundSpawnTool, DelegationTool, SubagentBudgetReservation, SubagentDelegationCaps, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentGrant, SubagentReservationAmounts, WorkerOperationTool, narrowSubagentGrant } from "./core/SubagentContract.mjs";
+import { RunUsageReport, unknownRunTotals } from "./core/Usage.mjs";
+import { WorkerCompletion, WorkerContext, WorkerError, WorkerPage, WorkerRef, WorkerReport, WorkerStarted, WorkerSummary } from "./core/Worker.mjs";
+import { BackgroundReporting, SubagentHost, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
+import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-BLyETCPo.mjs";
+import { RunEventSink } from "./engine/RunEventSink.mjs";
+import { SubagentBudgetExhausted, SubagentObservedUsage, SubagentReservationRequest, SubagentReservations, makeBudgetReservationId } from "./capabilities/SubagentReservations.mjs";
+import { t as utf8Bytes } from "./utf8-BYfhEkcj.mjs";
+import { Tool, Toolkit } from "effect/unstable/ai";
+import { Cause, Clock, Context, Crypto, Duration, Effect, Encoding, Exit, Layer, Option, Ref, Schema, Scope, Stream } from "effect";
+//#region src/capabilities/internal/subagent-contract.ts
+const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+const Natural = Schema.Natural;
+const FinitePositiveDuration = Schema.Duration.pipe(Schema.refine((duration) => Duration.isFinite(duration) && Duration.isPositive(duration), { expected: "a finite positive duration" }));
+const SubagentPolicyFields = Schema.Struct({
+	/** Total invocation slots, including reserved descendants, available through this delegation budget. */
+	maxChildren: PositiveInt,
+	/** Concurrently executing children per parent Run. */
+	maxConcurrency: PositiveInt,
+	/** Invocation slots held for the entire descendant subtree; omitted reserves zero. */
+	descendantInvocations: Schema.optionalKey(Natural),
+	/** Model turns reserved for each child invocation. */
+	maxTurns: PositiveInt,
+	/** Tool Calls reserved for each child invocation. */
+	maxToolCalls: PositiveInt,
+	/** Wall-clock duration reserved for each child invocation. */
+	maxDuration: FinitePositiveDuration,
+	maxInputTokens: Schema.optionalKey(PositiveInt),
+	maxOutputTokens: Schema.optionalKey(PositiveInt),
+	maxCostMicrousd: Schema.optionalKey(Natural),
+	maxResultBytes: Schema.optionalKey(PositiveInt)
+});
+/**
+* Finite delegation bounds declared by one Subagent capability.
+* Structural limits are hard limits; token
+* and cost caps are optional and enforced only as honestly as provider
+* reporting allows.
+*/
+var SubagentPolicy = class extends Schema.Class("@effect-agent/capabilities/SubagentPolicy")(SubagentPolicyFields) {
+	/** Normalize and validate finite delegation bounds, throwing on invalid input. */
+	static make(input) {
+		return super.make({
+			...input,
+			maxDuration: Duration.fromInputUnsafe(input.maxDuration)
+		});
+	}
+};
+const BoundedFailureText = Schema.String.check(Schema.isMaxLength(4096));
+/**
+* Delegation preflight denied before any child started.
+* No reservation, identity, or event exists for the
+* denied invocation; retry requires a new authorized parent Tool Call.
+*/
+var SubagentPrestartDenied = class extends Schema.TaggedError()("SubagentPrestartDenied", {
+	delegationId: DelegationId,
+	targetAgentId: AgentId,
+	reason: Schema.Literals([
+		"nested-delegation",
+		"grant-violation",
+		"budget-conflict"
+	]),
+	message: BoundedFailureText
+}) {};
+/**
+* Input or result projection failed its Schema or bounds.
+* Fail closed: the message is a fixed description and
+* never carries the raw child value.
+*/
+var SubagentProjectionFailure = class extends Schema.TaggedError()("SubagentProjectionFailure", {
+	delegationId: DelegationId,
+	stage: Schema.Literals(["input", "result"]),
+	message: BoundedFailureText
+}) {};
+const millisOfMaxDuration = (policy) => Math.max(1, Math.ceil(Duration.toMillis(policy.maxDuration)));
+/**
+* Derive the parent-Run delegation caps registered with
+* `SubagentReservations` from one delegation policy: the per-invocation
+* bounds scaled by `maxChildren` plus the invocation and concurrency limits.
+*/
+const delegationCapsFromPolicy = (policy) => SubagentDelegationCaps.make({
+	maxTotalChildInvocations: policy.maxChildren,
+	maxConcurrentChildren: policy.maxConcurrency,
+	maxTurns: policy.maxChildren * policy.maxTurns,
+	maxToolCalls: policy.maxChildren * policy.maxToolCalls,
+	maxDurationMillis: policy.maxChildren * millisOfMaxDuration(policy),
+	...policy.maxInputTokens === void 0 ? {} : { maxInputTokens: policy.maxChildren * policy.maxInputTokens },
+	...policy.maxOutputTokens === void 0 ? {} : { maxOutputTokens: policy.maxChildren * policy.maxOutputTokens },
+	...policy.maxCostMicrousd === void 0 ? {} : { maxCostMicrousd: policy.maxChildren * policy.maxCostMicrousd },
+	...policy.maxResultBytes === void 0 ? {} : { maxResultBytes: policy.maxChildren * policy.maxResultBytes }
+});
+/** Derive the all-or-nothing per-invocation reservation from one delegation policy. */
+const delegationAllocationFromPolicy = (policy) => SubagentReservationAmounts.make({
+	turns: policy.maxTurns,
+	toolCalls: policy.maxToolCalls,
+	durationMillis: millisOfMaxDuration(policy),
+	inputTokens: policy.maxInputTokens ?? 0,
+	outputTokens: policy.maxOutputTokens ?? 0,
+	costMicrousd: policy.maxCostMicrousd ?? 0,
+	resultBytes: policy.maxResultBytes ?? 0
+});
+//#endregion
+//#region src/capabilities/internal/subagent-policy.ts
+const resolveSubagentPolicy = (delegation, parent, parentCaps, mode = "conserved", resolvedTarget) => {
+	const parentCeiling = mode === "conserved" ? parent : void 0;
+	const inherited = resolvedTarget ?? AgentPolicy.resolve(delegation.target.policyOverrides ?? delegation.target.policy, parent);
+	const policy = delegation.policy ?? SubagentPolicy.make({
+		maxChildren: parent.maxToolCalls,
+		maxConcurrency: parent.toolConcurrency,
+		maxTurns: Math.min(inherited.maxTurns, parent.maxTurns),
+		maxToolCalls: Math.min(inherited.maxToolCalls, parent.maxToolCalls),
+		maxDuration: Duration.min(inherited.maxDuration, parent.maxDuration),
+		...parent.tokenBudget === void 0 ? {} : {
+			maxInputTokens: parent.tokenBudget,
+			maxOutputTokens: parent.tokenBudget
+		},
+		...parent.costBudgetMicrousd === void 0 ? {} : { maxCostMicrousd: parent.costBudgetMicrousd },
+		maxResultBytes: parent.toolResultBounds.maxBytes
+	});
+	const tokenCeiling = policy.maxInputTokens === void 0 || policy.maxOutputTokens === void 0 ? Math.min(inherited.tokenBudget ?? Infinity, parentCeiling?.tokenBudget ?? Infinity) : Math.min(inherited.tokenBudget ?? Infinity, parentCeiling?.tokenBudget ?? Infinity, policy.maxInputTokens + policy.maxOutputTokens);
+	const childPolicy = AgentPolicy.make({
+		...inherited,
+		maxTurns: Math.min(inherited.maxTurns, policy.maxTurns, parentCeiling?.maxTurns ?? Infinity),
+		maxToolCalls: Math.min(inherited.maxToolCalls, policy.maxToolCalls, parentCeiling?.maxToolCalls ?? Infinity),
+		maxDuration: Duration.min(Duration.min(inherited.maxDuration, policy.maxDuration), parentCeiling?.maxDuration ?? Duration.infinity),
+		toolConcurrency: Math.min(inherited.toolConcurrency, parentCeiling?.toolConcurrency ?? Infinity),
+		...parentCeiling === void 0 ? {} : { toolResultBounds: { maxBytes: Math.min(inherited.toolResultBounds.maxBytes, parentCeiling.toolResultBounds.maxBytes, Math.max(256, policy.maxResultBytes ?? Infinity)) } },
+		...tokenCeiling === Infinity ? {} : {
+			tokenBudget: tokenCeiling,
+			completionReserveTokens: Math.min(inherited.completionReserveTokens, tokenCeiling)
+		},
+		...Math.min(inherited.costBudgetMicrousd ?? Infinity, parentCeiling?.costBudgetMicrousd ?? Infinity, policy.maxCostMicrousd ?? Infinity) === Infinity ? {} : { costBudgetMicrousd: Math.min(inherited.costBudgetMicrousd ?? Infinity, parentCeiling?.costBudgetMicrousd ?? Infinity, policy.maxCostMicrousd ?? Infinity) }
+	});
+	const caps = parentCaps ?? (delegation.policy === void 0 ? SubagentDelegationCaps.make({
+		maxTotalChildInvocations: parent.maxToolCalls,
+		maxConcurrentChildren: parent.toolConcurrency,
+		maxTurns: parent.maxTurns,
+		maxToolCalls: parent.maxToolCalls,
+		maxDurationMillis: Math.ceil(Duration.toMillis(parent.maxDuration)),
+		...parent.tokenBudget === void 0 ? {} : {
+			maxInputTokens: parent.tokenBudget,
+			maxOutputTokens: parent.tokenBudget
+		},
+		...parent.costBudgetMicrousd === void 0 ? {} : { maxCostMicrousd: parent.costBudgetMicrousd }
+	}) : delegationCapsFromPolicy(policy));
+	return {
+		policy,
+		childPolicy,
+		allocation: delegationAllocationFromPolicy(policy),
+		caps
+	};
+};
+const resolveToolCallAllowance = (option, parameters, policy, childPolicy) => {
+	if (option === void 0) return childPolicy.maxToolCalls;
+	const extracted = option.fromParameters?.(parameters);
+	const requested = extracted !== void 0 && Number.isFinite(extracted) ? extracted : Number.isFinite(option.default) ? option.default : policy.maxToolCalls;
+	return Math.min(Math.max(1, Math.floor(requested)), policy.maxToolCalls, childPolicy.maxToolCalls);
+};
+/** Conservative subtree remainder after reserving this Run's own full execution ceiling. */
+const residualSubagentCaps = (declared, parent, inherited, independentRun = false) => {
+	const allocation = inherited.allocation;
+	const remaining = (allocated, own, cap) => Math.min(cap ?? Infinity, Math.max(0, allocated - own));
+	return SubagentDelegationCaps.make({
+		maxTotalChildInvocations: Math.min(declared.maxTotalChildInvocations ?? Infinity, inherited.descendantInvocations ?? 0),
+		maxConcurrentChildren: Math.min(declared.maxConcurrentChildren ?? Infinity, parent.toolConcurrency, inherited.descendantInvocations ?? 0),
+		maxTurns: remaining(allocation.turns, parent.maxTurns, declared.maxTurns),
+		maxToolCalls: remaining(allocation.toolCalls, parent.maxToolCalls, declared.maxToolCalls),
+		maxDurationMillis: remaining(allocation.durationMillis, Math.ceil(Duration.toMillis(parent.maxDuration)), declared.maxDurationMillis),
+		...independentRun && inherited.caps.maxInputTokens === void 0 && allocation.inputTokens === 0 && parent.tokenBudget === void 0 ? declared.maxInputTokens === void 0 ? {} : { maxInputTokens: declared.maxInputTokens } : { maxInputTokens: remaining(allocation.inputTokens, parent.tokenBudget ?? allocation.inputTokens, declared.maxInputTokens) },
+		...independentRun && inherited.caps.maxOutputTokens === void 0 && allocation.outputTokens === 0 && parent.tokenBudget === void 0 ? declared.maxOutputTokens === void 0 ? {} : { maxOutputTokens: declared.maxOutputTokens } : { maxOutputTokens: remaining(allocation.outputTokens, parent.tokenBudget ?? allocation.outputTokens, declared.maxOutputTokens) },
+		...independentRun && inherited.caps.maxCostMicrousd === void 0 && allocation.costMicrousd === 0 && parent.costBudgetMicrousd === void 0 ? declared.maxCostMicrousd === void 0 ? {} : { maxCostMicrousd: declared.maxCostMicrousd } : { maxCostMicrousd: remaining(allocation.costMicrousd, parent.costBudgetMicrousd ?? allocation.costMicrousd, declared.maxCostMicrousd) },
+		maxResultBytes: remaining(allocation.resultBytes, parent.toolResultBounds.maxBytes, declared.maxResultBytes)
+	});
+};
+//#endregion
+//#region src/capabilities/internal/subagent-reporting.ts
+const projectReport = (declaration) => Effect.fn("Subagent.projectReport")(function* (report) {
+	const { worker, observation } = report;
+	const invalid = () => WorkerReportPreparationFailure.make({ stage: "projection" });
+	if (worker.delegationId !== declaration.delegationId || worker.targetAgentId !== declaration.target.id || observation.receipt.threadId !== worker.threadId) return yield* invalid();
+	const base = {
+		_tag: "Settled",
+		worker,
+		receipt: yield* Schema.decodeEffect(Receipt)(observation.receipt).pipe(Effect.mapError(invalid)),
+		runId: observation.runId,
+		settlementId: observation.settlementId
+	};
+	let projected;
+	let encodedResult = null;
+	if (observation.outcome === "completed") {
+		const parameters = yield* Schema.decodeUnknownEffect(declaration.parameters)(observation.encodedParameters).pipe(Effect.mapError(invalid));
+		const output = yield* Schema.decodeUnknownEffect(declaration.target.output)(observation.encodedResult).pipe(Effect.mapError(invalid));
+		const result = yield* declaration.projectResult(output, { budgetExhausted: observation.budgetExhausted }, parameters);
+		const encoded = yield* Schema.encodeEffect(declaration.success)(result).pipe(Effect.mapError(invalid));
+		const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError(invalid));
+		if (utf8ByteLength(JSON.stringify(json)) > (declaration.policy?.maxResultBytes ?? declaration.target.policy.toolResultBounds.maxBytes)) return yield* invalid();
+		projected = {
+			...base,
+			outcome: "completed",
+			result
+		};
+		encodedResult = json;
+	} else projected = {
+		...base,
+		outcome: observation.outcome,
+		failure: SubagentExecutionFailure.make({
+			delegationId: declaration.delegationId,
+			targetAgentId: declaration.target.id,
+			classification: observation.outcome === "failed" ? "child-failed" : "child-aborted",
+			childThreadId: worker.threadId,
+			childSubmissionId: observation.receipt.submissionId,
+			childRunId: observation.runId,
+			errorTag: observation.outcome === "failed" ? "WorkerFailed" : "WorkerAborted",
+			message: observation.outcome === "failed" ? "Worker input failed" : "Worker input was aborted"
+		})
+	};
+	return {
+		projected,
+		encodedResult
+	};
+});
+/** Framework reporting shares the same bounded declaration projection as custom mapping. */
+const automaticReporting = (declaration) => ({
+	delegationId: declaration.delegationId,
+	target: declaration.target,
+	mode: "standard",
+	prepare: Effect.fn("Subagent.automaticReport")(function* (report) {
+		const { projected, encodedResult } = yield* projectReport(declaration)(report);
+		const encoded = projected.outcome === "completed" ? {
+			...projected,
+			result: encodedResult
+		} : {
+			...projected,
+			failure: yield* Schema.encodeEffect(SubagentExecutionFailure)(projected.failure).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" })))
+		};
+		return {
+			encodedInput: null,
+			message: yield* Schema.decodeEffect(WorkerCompletion)({
+				_tag: "WorkerCompletion",
+				schemaVersion: 1,
+				report: encoded,
+				budgetExhausted: report.observation.budgetExhausted
+			}).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" })))
+		};
+	})
+});
+/**
+* Define an optional application-specific conversion for `background({ reportToParent: report })`.
+* Existing Agent Registration `reporting` arrays remain supported. The input Schema must be the coordinator Definition's exact input Schema.
+* Preparation is bounded by the durable host; a retained prepared envelope is never reprojected
+* during delivery retries. The callback should be deterministic and have no external side effects.
+*/
+const reporting = (declaration, options) => {
+	const prepare = Effect.fn("Subagent.reporting.prepare")(function* (report) {
+		const { projected } = yield* projectReport(declaration)(report);
+		const input = yield* options.prepare(projected);
+		const encoded = yield* Schema.encodeEffect(options.input)(input).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "input" })));
+		return { encodedInput: yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "input" }))) };
+	});
+	return Object.freeze({
+		delegationId: declaration.delegationId,
+		target: declaration.target,
+		input: options.input,
+		prepare
+	});
+};
+/**
+* Adapt a report expressed in a receiving worker declaration's Parameters to its Agent input.
+* Use this on that worker's registration when it can itself launch reporting workers. This
+* explicit conversion preserves custom Parameters and charges the next input to its ancestor.
+*/
+const reportingToWorker = (report, destination) => {
+	if (report.input !== destination.parameters) throw new TypeError("Worker reporting must use the destination declaration's Parameters Schema");
+	return Object.freeze({
+		delegationId: report.delegationId,
+		target: report.target,
+		input: destination.target.input,
+		destination: {
+			delegationId: destination.delegationId,
+			target: destination.target
+		},
+		prepare: Effect.fn("Subagent.reportingToWorker.prepare")(function* (run) {
+			const encodedParameters = (yield* report.prepare(run)).encodedInput;
+			const invalid = () => WorkerReportPreparationFailure.make({ stage: "input" });
+			const parameters = yield* Schema.decodeEffect(destination.parameters)(encodedParameters).pipe(Effect.mapError(invalid));
+			const input = yield* destination.prepareInput(parameters, {
+				source: "programmatic",
+				delegationId: destination.delegationId,
+				parent: {
+					agentId: run.context.source.agentId,
+					threadId: run.context.source.threadId
+				}
+			});
+			const encoded = yield* Schema.encodeEffect(destination.target.input)(input).pipe(Effect.mapError(invalid));
+			return {
+				encodedInput: yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError(invalid)),
+				encodedParameters
+			};
+		})
+	});
+};
+//#endregion
+//#region src/capabilities/internal/subagent-background.ts
+/** Portable identity checked against this declaration; possession grants no authority. */
+const Worker = (declaration) => WorkerRef.check(Schema.makeFilter((worker) => worker.delegationId === declaration.delegationId && worker.targetAgentId === declaration.target.id)).pipe(Schema.brand(`@effect-agent/Worker/${declaration.name}`));
+/** Observes one exact Receipt. Terminal failure data never includes raw child output. */
+const WorkerObservation = (success) => Schema.Union([
+	Schema.Struct({
+		_tag: Schema.Literal("Pending"),
+		receipt: Receipt
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Settled"),
+		receipt: Receipt,
+		runId: RunId,
+		settlementId: SettlementId,
+		outcome: Schema.Literal("completed"),
+		result: success
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Settled"),
+		receipt: Receipt,
+		runId: Schema.optionalKey(RunId),
+		settlementId: SettlementId,
+		outcome: Schema.Literals(["failed", "aborted"]),
+		failure: SubagentExecutionFailure
+	})
+]);
+const host = Effect.serviceOption(SubagentHost).pipe(Effect.flatMap((service) => Option.match(service, {
+	onNone: () => WorkerError.make({
+		operation: "context",
+		reason: "unavailable"
+	}),
+	onSome: Effect.succeed
+})));
+const receiptEqual = (left, right) => left.threadId === right.threadId && left.submissionId === right.submissionId && left.receiptId === right.receiptId && left.queueSequence === right.queueSequence;
+const operations = (declaration) => {
+	const workerSchema = Worker(declaration);
+	const projectionFailure = (stage) => SubagentProjectionFailure.make({
+		delegationId: declaration.delegationId,
+		stage,
+		message: stage === "input" ? "Worker input did not satisfy the declaration Schema" : "Worker result did not satisfy the declaration Schema"
+	});
+	const validateWorker = (worker, operation) => Schema.decodeUnknownEffect(workerSchema)(worker).pipe(Effect.mapError(() => WorkerError.make({
+		operation,
+		reason: "worker-mismatch"
+	})));
+	const validateReceipt = (worker, receipt, operation) => Schema.decodeEffect(Receipt.check(Schema.makeFilter((value) => value.threadId === worker.threadId)))(receipt).pipe(Effect.mapError(() => WorkerError.make({
+		operation,
+		reason: "receipt-mismatch"
+	})));
+	const context = host.pipe(Effect.flatMap((service) => service.context), Effect.flatMap(Schema.decodeUnknownEffect(Schema.toType(WorkerContext))), Effect.mapError((error) => Schema.is(WorkerError)(error) ? error : WorkerError.make({
+		operation: "context",
+		reason: "corrupt"
+	})));
+	const prepare = Effect.fn("Subagent.prepareWorkerInput")(function* (parameters, caller) {
+		const encodedParameters = yield* Schema.encodeEffect(declaration.parameters)(parameters).pipe(Effect.mapError(() => projectionFailure("input")));
+		const source = caller.source;
+		const preparation = source._tag === "tool" ? {
+			source: "tool",
+			delegationId: declaration.delegationId,
+			toolCallId: source.toolCallId,
+			parent: {
+				agentId: source.agentId,
+				threadId: source.threadId,
+				runId: source.runId
+			}
+		} : {
+			source: "programmatic",
+			delegationId: declaration.delegationId,
+			parent: {
+				agentId: source.agentId,
+				threadId: source.threadId
+			}
+		};
+		const input = yield* declaration.prepareInput(parameters, preparation);
+		return {
+			encodedParameters,
+			encodedInput: yield* Schema.encodeEffect(declaration.target.input)(input).pipe(Effect.mapError(() => projectionFailure("input")))
+		};
+	});
+	const validateKey = (key, operation) => Schema.decodeEffect(IdempotencyKey)(key).pipe(Effect.mapError(() => WorkerError.make({
+		operation,
+		reason: "idempotency-conflict"
+	})));
+	return {
+		start: Effect.fn("Subagent.start")(function* (parameters, options) {
+			const service = yield* host;
+			const caller = yield* context;
+			const key = yield* validateKey(options.idempotencyKey, "start");
+			const grant = narrowSubagentGrant(declaration.grant, caller.grant);
+			if (caller.depth + 1 > grant.maxDepth) return yield* SubagentPrestartDenied.make({
+				delegationId: declaration.delegationId,
+				targetAgentId: declaration.target.id,
+				reason: "nested-delegation",
+				message: "Worker start exceeds the inherited depth ceiling"
+			});
+			if (!(caller.grant?.childLifetimes ?? ["attached", "background"]).includes("background")) return yield* SubagentPrestartDenied.make({
+				delegationId: declaration.delegationId,
+				targetAgentId: declaration.target.id,
+				reason: "grant-violation",
+				message: "The inherited grant does not permit background children"
+			});
+			const prepared = yield* prepare(parameters, caller);
+			const effectiveTarget = yield* service.resolveTargetPolicy({
+				target: declaration.target,
+				encodedInput: prepared.encodedInput
+			});
+			const resolvedTarget = Option.getOrUndefined(effectiveTarget);
+			const resolved = resolveSubagentPolicy(declaration, options.budgetScope === "worker-run" ? resolvedTarget ?? declaration.target.policy : caller.policy, void 0, options.budgetScope === "worker-run" ? "root-attached" : "conserved", resolvedTarget);
+			const encodedGrant = yield* Schema.encodeEffect(SubagentGrant)(grant).pipe(Effect.mapError(() => projectionFailure("input")));
+			const started = yield* service.start({
+				...prepared,
+				delegationId: declaration.delegationId,
+				target: declaration.target,
+				idempotencyKey: key,
+				...options.budgetScope === void 0 ? {} : { budgetScope: options.budgetScope },
+				encodedGrant,
+				policy: resolved.childPolicy,
+				budget: SubagentBudgetReservation.make({
+					caps: resolved.caps,
+					allocation: resolved.allocation,
+					...resolved.policy.descendantInvocations === void 0 ? {} : { descendantInvocations: resolved.policy.descendantInvocations }
+				}),
+				toolCallAllowance: resolveToolCallAllowance(declaration.toolCallAllowance, parameters, resolved.policy, resolved.childPolicy)
+			});
+			const validated = yield* Schema.decodeEffect(WorkerStarted)(started).pipe(Effect.mapError(() => WorkerError.make({
+				operation: "start",
+				reason: "corrupt"
+			})));
+			return {
+				worker: yield* validateWorker(validated.worker, "start"),
+				receipt: validated.receipt
+			};
+		}),
+		followUp: Effect.fn("Subagent.followUp")(function* (worker, parameters, options) {
+			const service = yield* host;
+			const validated = yield* validateWorker(worker, "followUp");
+			const caller = yield* context;
+			const key = yield* validateKey(options.idempotencyKey, "followUp");
+			const prepared = yield* prepare(parameters, caller);
+			return yield* validateReceipt(validated, yield* service.followUp({
+				...prepared,
+				worker: validated,
+				target: declaration.target,
+				idempotencyKey: key
+			}), "followUp");
+		}),
+		observe: Effect.fn("Subagent.observeWorker")(function* (operation, worker, receipt) {
+			const service = yield* host;
+			const validated = yield* validateWorker(worker, operation);
+			const requested = yield* validateReceipt(validated, receipt, operation);
+			const observed = yield* service[operation]({
+				worker: validated,
+				target: declaration.target,
+				receipt: requested
+			});
+			const returned = yield* validateReceipt(validated, observed.receipt, operation);
+			if (!receiptEqual(returned, requested)) return yield* WorkerError.make({
+				operation,
+				reason: "receipt-mismatch"
+			});
+			if (observed._tag === "Pending") {
+				if (operation === "await") return yield* WorkerError.make({
+					operation,
+					reason: "corrupt"
+				});
+				return {
+					_tag: "Pending",
+					receipt: returned
+				};
+			}
+			const base = {
+				_tag: "Settled",
+				receipt: returned,
+				...observed.runId === void 0 ? {} : { runId: yield* Schema.decodeEffect(RunId)(observed.runId).pipe(Effect.mapError(() => WorkerError.make({
+					operation,
+					reason: "corrupt"
+				}))) },
+				settlementId: yield* Schema.decodeEffect(SettlementId)(observed.settlementId).pipe(Effect.mapError(() => WorkerError.make({
+					operation,
+					reason: "corrupt"
+				})))
+			};
+			if (observed.outcome === "failed" || observed.outcome === "aborted") return {
+				...base,
+				outcome: observed.outcome,
+				failure: SubagentExecutionFailure.make({
+					delegationId: declaration.delegationId,
+					targetAgentId: declaration.target.id,
+					classification: observed.outcome === "failed" ? "child-failed" : "child-aborted",
+					childThreadId: worker.threadId,
+					childSubmissionId: returned.submissionId,
+					...base.runId === void 0 ? {} : { childRunId: base.runId },
+					errorTag: observed.outcome === "failed" ? "WorkerFailed" : "WorkerAborted",
+					message: observed.outcome === "failed" ? "Worker input failed" : "Worker input was aborted"
+				})
+			};
+			if (observed.outcome !== "completed" || base.runId === void 0 || typeof observed.budgetExhausted !== "boolean") return yield* WorkerError.make({
+				operation,
+				reason: "corrupt"
+			});
+			const parameters = yield* Schema.decodeUnknownEffect(declaration.parameters)(observed.encodedParameters).pipe(Effect.mapError(() => projectionFailure("result")));
+			const output = yield* Schema.decodeUnknownEffect(declaration.target.output)(observed.encodedResult).pipe(Effect.mapError(() => projectionFailure("result")));
+			const result = yield* declaration.projectResult(output, { budgetExhausted: observed.budgetExhausted }, parameters);
+			const encoded = yield* Schema.encodeEffect(declaration.success)(result).pipe(Effect.mapError(() => projectionFailure("result")));
+			const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError(() => projectionFailure("result")));
+			const caller = yield* context;
+			if (utf8ByteLength(JSON.stringify(json)) > (declaration.policy?.maxResultBytes ?? caller.policy.toolResultBounds.maxBytes)) return yield* projectionFailure("result");
+			return yield* Schema.decodeUnknownEffect(Schema.toType(WorkerObservation(declaration.success)))({
+				...base,
+				outcome: "completed",
+				result
+			}).pipe(Effect.mapError(() => projectionFailure("result")));
+		}),
+		list: Effect.fn("Subagent.list")(function* (options = {}) {
+			const service = yield* host;
+			const limit = yield* Schema.decodeEffect(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)))(options.limit ?? 20).pipe(Effect.mapError(() => WorkerError.make({
+				operation: "list",
+				reason: "capacity"
+			})));
+			const page = yield* service.list({
+				delegationId: declaration.delegationId,
+				target: declaration.target,
+				limit,
+				...options.after === void 0 ? {} : { after: options.after }
+			});
+			const validated = yield* Schema.decodeEffect(WorkerPage)(page).pipe(Effect.mapError(() => WorkerError.make({
+				operation: "list",
+				reason: "corrupt"
+			})));
+			if (validated.items.length > limit) return yield* WorkerError.make({
+				operation: "list",
+				reason: "corrupt"
+			});
+			const items = [];
+			for (const item of validated.items) {
+				const worker = yield* validateWorker(item.worker, "list");
+				const latestReceipt = item.latestReceipt === null ? null : yield* validateReceipt(worker, item.latestReceipt, "list");
+				items.push({
+					...item,
+					worker,
+					latestReceipt
+				});
+			}
+			return {
+				items,
+				next: validated.next
+			};
+		}),
+		cancel: Effect.fn("Subagent.cancel")(function* (worker, receipt) {
+			const service = yield* host;
+			const validated = yield* validateWorker(worker, "cancel");
+			const requested = yield* validateReceipt(validated, receipt, "cancel");
+			yield* service.cancel({
+				worker: validated,
+				target: declaration.target,
+				receipt: requested
+			});
+		})
+	};
+};
+/** Start a host-managed worker. Retrying the same explicit key reuses the accepted input. */
+const start = (declaration, parameters, options) => operations(declaration).start(parameters, options);
+/** Admit typed follow-up parameters to the same worker Thread. */
+const followUp = (declaration, worker, parameters, options) => operations(declaration).followUp(worker, parameters, options);
+/** Inspect a continuing worker with the same summary contract returned by list. */
+const summary = (declaration, worker) => Effect.gen(function* () {
+	const service = yield* host;
+	const validated = yield* Schema.decodeEffect(Worker(declaration))(worker).pipe(Effect.mapError(() => WorkerError.make({
+		operation: "inspect",
+		reason: "worker-mismatch"
+	})));
+	const result = yield* service.summary({
+		worker: validated,
+		target: declaration.target
+	});
+	const value = yield* Schema.decodeEffect(WorkerSummary)(result).pipe(Effect.mapError(() => WorkerError.make({
+		operation: "inspect",
+		reason: "corrupt"
+	})));
+	if (value.worker.threadId !== validated.threadId || value.worker.delegationId !== validated.delegationId || value.worker.targetAgentId !== validated.targetAgentId || value.latestReceipt !== null && value.latestReceipt.threadId !== validated.threadId) return yield* WorkerError.make({
+		operation: "inspect",
+		reason: "worker-mismatch"
+	});
+	return {
+		...value,
+		worker: validated
+	};
+});
+function inspect(declaration, worker, receipt) {
+	return receipt === void 0 ? summary(declaration, worker) : operations(declaration).observe("inspect", worker, receipt);
+}
+/** Read an authorized finite history snapshot; pass the last emitted sequence to resume. */
+const observe = (declaration, worker, options = {}) => Stream.unwrap(Effect.gen(function* () {
+	const service = yield* host;
+	const validated = yield* Schema.decodeEffect(Worker(declaration))(worker).pipe(Effect.mapError(() => WorkerError.make({
+		operation: "observe",
+		reason: "worker-mismatch"
+	})));
+	const after = options.after === void 0 ? void 0 : yield* Schema.decodeEffect(Schema.Natural)(options.after).pipe(Effect.mapError(() => WorkerError.make({
+		operation: "observe",
+		reason: "corrupt"
+	})));
+	return service.observe({
+		worker: validated,
+		target: declaration.target,
+		...after === void 0 ? {} : { after }
+	});
+}));
+/** Wait for the exact Receipt. Interrupting this Effect never cancels accepted work. */
+const awaitWorker = (declaration, worker, receipt) => operations(declaration).observe("await", worker, receipt);
+/** List only workers visible through the caller-bound host facet. */
+const list = (declaration, options = {}) => operations(declaration).list(options);
+/** Request cancellation of exactly one Receipt; JoinedToHost remains a typed conflict. */
+const cancel = (declaration, worker, receipt) => operations(declaration).cancel(worker, receipt);
+const ReceiptParameters = (declaration) => Schema.Struct({
+	worker: Worker(declaration),
+	receipt: Receipt
+});
+const WorkerParameters = (declaration) => Schema.Struct({ worker: Worker(declaration) });
+const Summary = (declaration) => Schema.Struct({
+	worker: Worker(declaration),
+	latestReceipt: Schema.NullOr(Receipt),
+	state: Schema.Literals([
+		"starting",
+		"active",
+		"idle"
+	])
+});
+const FollowUpParameters = (declaration, parameters) => Schema.Struct({
+	worker: Worker(declaration),
+	parameters
+});
+const ListParameters = Schema.Struct({
+	limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100))),
+	after: Schema.optionalKey(ThreadId)
+});
+const Started = (declaration) => Schema.Struct({
+	worker: Worker(declaration),
+	receipt: Receipt
+}).check(Schema.makeFilter((value) => value.worker.threadId === value.receipt.threadId));
+const Page = (declaration) => Schema.Struct({
+	items: Schema.Array(Schema.Struct({
+		worker: Worker(declaration),
+		latestReceipt: Schema.NullOr(Receipt),
+		state: Schema.Literals([
+			"starting",
+			"active",
+			"idle"
+		])
+	})).check(Schema.isMaxLength(100)),
+	next: Schema.NullOr(ThreadId)
+});
+const preparationFailure = (failure) => Schema.Union([
+	failure,
+	SubagentProjectionFailure,
+	WorkerError
+]);
+const startFailure = (failure) => Schema.Union([
+	failure,
+	SubagentProjectionFailure,
+	SubagentPrestartDenied,
+	WorkerError
+]);
+const cancelFailure = Schema.Union([WorkerError, JoinedToHost]);
+const modelKey = Effect.fn("Subagent.workerToolKey")(function* (operation) {
+	const caller = yield* (yield* host).context;
+	if (caller.source._tag !== "tool") return yield* WorkerError.make({
+		operation,
+		reason: "denied"
+	});
+	const source = caller.source;
+	const crypto = yield* Crypto.Crypto;
+	const bytes = utf8Bytes(JSON.stringify([
+		"worker-tool-v1",
+		operation,
+		source.agentId,
+		source.threadId,
+		source.runId,
+		source.toolCallId
+	]));
+	const digest = yield* crypto.digest("SHA-256", bytes).pipe(Effect.mapError(() => WorkerError.make({
+		operation,
+		reason: "unavailable"
+	})));
+	return yield* Schema.decodeEffect(IdempotencyKey)(`worker:${Encoding.encodeHex(digest)}`).pipe(Effect.mapError(() => WorkerError.make({
+		operation,
+		reason: "unavailable"
+	})));
+});
+let reportingServiceId = 0;
+/**
+* Derive optional native AI Tools and their handler Layer from one immutable declaration.
+* Projection services are captured by the Layer; the host and stable-key Crypto service remain
+* invocation dependencies. The attached `.tool` and its suspension behavior are unchanged.
+*/
+const background$1 = (declaration, selected) => {
+	const report = selected.reportToParent === true ? automaticReporting(declaration) : selected.reportToParent;
+	if (report !== void 0 && (report.delegationId !== declaration.delegationId || report.target !== declaration.target)) throw new TypeError("Background reporting must use the same subagent declaration and target");
+	const reportService = Context.Service(`@effect-agent/capabilities/BackgroundReport/${declaration.name}/${reportingServiceId++}`);
+	const descriptor = report === void 0 ? void 0 : {
+		...report,
+		prepare: (value) => Effect.flatMap(Effect.serviceOption(reportService), (service) => Option.isSome(service) ? service.value.prepare(value) : WorkerReportPreparationFailure.make({ stage: "preparation" }))
+	};
+	const ops = operations(declaration);
+	const failure = preparationFailure(declaration.failure);
+	const receiptParameters = ReceiptParameters(declaration);
+	const startTool = Tool.make(`${declaration.name}_start`, {
+		description: `Start ${declaration.name} in the background and return its worker identity and Receipt.`,
+		parameters: declaration.parameters,
+		success: Started(declaration),
+		failure: startFailure(declaration.failure)
+	}).annotate(WorkerOperationTool, true).annotate(BackgroundSpawnTool, true).addDependency(SubagentHost).addDependency(Crypto.Crypto);
+	const followUpTool = Tool.make(`${declaration.name}_follow_up`, {
+		description: `Send typed follow-up input to an existing ${declaration.name} worker.`,
+		parameters: FollowUpParameters(declaration, declaration.parameters),
+		success: Receipt,
+		failure
+	}).annotate(WorkerOperationTool, true).addDependency(SubagentHost).addDependency(Crypto.Crypto);
+	const inspectTool = Tool.make(`${declaration.name}_inspect`, {
+		description: `Inspect one exact ${declaration.name} Receipt without waiting.`,
+		parameters: receiptParameters,
+		success: WorkerObservation(declaration.success),
+		failure
+	}).annotate(WorkerOperationTool, true).addDependency(SubagentHost);
+	const summaryTool = Tool.make(`${declaration.name}_summary`, {
+		description: `Inspect ${declaration.name}'s continuing worker state and latest accepted input.`,
+		parameters: WorkerParameters(declaration),
+		success: Summary(declaration),
+		failure: WorkerError
+	}).annotate(WorkerOperationTool, true).addDependency(SubagentHost);
+	const listTool = Tool.make(`${declaration.name}_list`, {
+		description: `List visible ${declaration.name} workers.`,
+		parameters: ListParameters,
+		success: Page(declaration),
+		failure: WorkerError
+	}).annotate(WorkerOperationTool, true).addDependency(SubagentHost);
+	const cancelTool = Tool.make(`${declaration.name}_cancel`, {
+		description: `Request cancellation of one exact ${declaration.name} Receipt.`,
+		parameters: receiptParameters,
+		success: Schema.Void,
+		failure: cancelFailure
+	}).annotate(WorkerOperationTool, true).addDependency(SubagentHost);
+	const chosen = Object.entries({
+		start: startTool,
+		followUp: followUpTool,
+		inspect: inspectTool,
+		summary: summaryTool,
+		list: listTool,
+		cancel: cancelTool
+	}).filter(([operation]) => selected[operation] === true).map(([, tool]) => tool.annotate(BackgroundReporting, descriptor));
+	const toolkit = Toolkit.make(...chosen);
+	const build = Effect.gen(function* () {
+		const captured = yield* Effect.context();
+		return {
+			[startTool.name]: (parameters) => Effect.gen(function* () {
+				const service = yield* host;
+				const idempotencyKey = yield* modelKey("start");
+				return yield* ops.start(parameters, {
+					idempotencyKey,
+					...selected.budgetScope === void 0 ? {} : { budgetScope: selected.budgetScope }
+				}).pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
+			}),
+			[followUpTool.name]: (parameters) => Effect.gen(function* () {
+				const service = yield* host;
+				const idempotencyKey = yield* modelKey("followUp");
+				return yield* ops.followUp(parameters.worker, parameters.parameters, { idempotencyKey }).pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
+			}),
+			[inspectTool.name]: (parameters) => Effect.gen(function* () {
+				const service = yield* host;
+				return yield* ops.observe("inspect", parameters.worker, parameters.receipt).pipe(Effect.provideService(SubagentHost, service), Effect.provide(captured));
+			}),
+			[listTool.name]: (parameters) => ops.list(parameters),
+			[summaryTool.name]: (parameters) => summary(declaration, parameters.worker),
+			[cancelTool.name]: (parameters) => ops.cancel(parameters.worker, parameters.receipt)
+		};
+	});
+	const reportingLayer = report === void 0 ? Layer.empty : Layer.effect(reportService, Effect.map(Effect.context(), (context) => ({
+		...report,
+		prepare: (value) => Effect.scoped(Effect.suspend(() => report.prepare(value))).pipe(Effect.provide(context), Effect.mapError((error) => Schema.is(WorkerReportPreparationFailure)(error) ? error : WorkerReportPreparationFailure.make({ stage: "preparation" })))
+	})));
+	const layer = Layer.merge(toolkit.toLayer(build), reportingLayer);
+	return Object.freeze({
+		tools: toolkit.tools,
+		toolkit,
+		layer
+	});
+};
+//#endregion
+//#region src/capabilities/Subagent.ts
+var Subagent_exports = /* @__PURE__ */ __exportAll({
+	SubagentDurableAccounting: () => SubagentDurableAccounting,
+	SubagentExecutionFailure: () => SubagentExecutionFailure,
+	SubagentExecutionFailureClassification: () => SubagentExecutionFailureClassification,
+	SubagentGrant: () => SubagentGrant,
+	SubagentPolicy: () => SubagentPolicy,
+	SubagentPrestartDenied: () => SubagentPrestartDenied,
+	SubagentProjectionFailure: () => SubagentProjectionFailure,
+	SubagentResult: () => SubagentResult,
+	Worker: () => Worker,
+	WorkerCompletion: () => WorkerCompletion,
+	WorkerObservation: () => WorkerObservation,
+	WorkerReport: () => WorkerReport,
+	await: () => awaitWorker,
+	background: () => background,
+	cancel: () => cancel,
+	define: () => define,
+	delegationAllocationFromPolicy: () => delegationAllocationFromPolicy,
+	delegationCapsFromPolicy: () => delegationCapsFromPolicy,
+	followUp: () => followUp,
+	inspect: () => inspect,
+	layer: () => layer,
+	list: () => list,
+	make: () => make,
+	observe: () => observe,
+	reporting: () => reporting,
+	reportingToWorker: () => reportingToWorker,
+	start: () => start
+});
+const decodeDelegationId = Schema.decodeSync(DelegationId);
+/** Default delegation result, preserving partial-output information. */
+const SubagentResult = (output) => Schema.Struct({
+	output,
+	budgetExhausted: Schema.Boolean
+});
+/**
+* Declare one attached delegation as a pure value.
+*
+* The returned `.tool` is a native Effect AI Tool whose handler dependencies
+* are exactly the engine-owned `AgentSpawner`, `RunEventSink`, and
+* `SubagentDurability` (SUB-003); runtime IDs have an overridable default.
+* The concrete child Binding arrives only through
+* `Subagent.layer`. Throws on an invalid delegation name. Nested declarations remain inert unless the
+* effective inherited grant and reserved subtree budget permit their lifetime and depth.
+*/
+const makeExplicit = (name, options) => {
+	const delegationId = decodeDelegationId(name);
+	const grant = options.grant ?? SubagentGrant.make({
+		allowedToolNames: Object.keys(options.target.toolkit.tools),
+		maxDepth: 1
+	});
+	const failureMode = options.failureMode ?? "error";
+	const containedFailure = Schema.Union([
+		options.failure,
+		SubagentPrestartDenied,
+		SubagentBudgetExhausted,
+		SubagentProjectionFailure,
+		SubagentExecutionFailure
+	]);
+	const returnModeTool = Tool.make(name, {
+		description: options.description,
+		parameters: options.parameters,
+		success: Schema.Union([options.success, containedFailure]),
+		failure: Schema.Union([ToolCallWaiting, SubagentDurabilityError]),
+		needsApproval: options.needsApproval
+	});
+	const errorModeTool = Tool.make(name, {
+		description: options.description,
+		parameters: options.parameters,
+		success: options.success,
+		failure: Schema.Union([
+			options.failure,
+			SubagentPrestartDenied,
+			SubagentBudgetExhausted,
+			SubagentProjectionFailure,
+			SubagentExecutionFailure,
+			ToolCallWaiting,
+			SubagentDurabilityError
+		]),
+		needsApproval: options.needsApproval
+	});
+	const tool = (failureMode === "return" ? returnModeTool : errorModeTool).annotate(DelegationTool, true).addDependency(AgentSpawner).addDependency(RunEventSink).addDependency(SubagentDurability).addDependency(IdGenerator$1);
+	return Object.freeze({
+		...options,
+		name,
+		delegationId,
+		grant,
+		failureMode,
+		containedFailure,
+		tool
+	});
+};
+function make(name, options) {
+	const success = options.success ?? SubagentResult(options.target.output);
+	const parameters = options.parameters ?? options.target.input;
+	const failure = options.failure ?? Schema.Never;
+	const inputValue = Schema.decodeUnknownEffect(Schema.toType(options.target.input));
+	const resultValue = Schema.decodeUnknownEffect(Schema.toType(success));
+	const needsApproval = options.needsApproval;
+	const prepareInput = options.prepareInput;
+	const projectResult = options.projectResult;
+	const projectionFailure = (stage) => SubagentProjectionFailure.make({
+		delegationId: decodeDelegationId(name),
+		stage,
+		message: stage === "input" ? "Delegation parameters did not satisfy the child input Schema" : "Child output did not satisfy the delegation success Schema"
+	});
+	const resolved = {
+		...options,
+		needsApproval: typeof needsApproval === "function" ? (input, context) => needsApproval(input, context) : needsApproval,
+		description: options.description ?? options.target.description,
+		parameters,
+		success,
+		failure,
+		prepareInput: (input, context) => prepareInput === void 0 ? inputValue(input).pipe(Effect.mapError(() => projectionFailure("input"))) : prepareInput(input, context),
+		projectResult: (output, context, input) => projectResult === void 0 ? resultValue({
+			output,
+			budgetExhausted: context.budgetExhausted
+		}).pipe(Effect.mapError(() => projectionFailure("result"))) : projectResult(output, context, input)
+	};
+	return options.failureMode === "return" ? makeExplicit(name, {
+		...resolved,
+		failureMode: "return"
+	}) : makeExplicit(name, {
+		...resolved,
+		failureMode: "error"
+	});
+}
+/** @deprecated Use `Subagent.make`. */
+const define = make;
+/**
+* The conservative final accounting summary the durable delegation handler
+* attaches to every settlement join. The handler has no live child usage stream at durable join
+* time, so every dimension conservatively consumes its full reservation and
+* releases nothing — unreported usage never creates budget. The coordinator
+* owns the canonical accounting decision on `SubagentJoined` and may replace
+* structural dimensions from canonical child evidence; this value is opaque
+* encoded policy math to the engine and to storage adapters (D8).
+*/
+var SubagentDurableAccounting = class extends Schema.Class("@effect-agent/capabilities/SubagentDurableAccounting")({
+	/** The per-invocation allocation reserved at establishment. */
+	allocation: SubagentReservationAmounts,
+	/** Final consumed decision per dimension. */
+	consumed: SubagentReservationAmounts,
+	/** Amounts returned to the parent: `allocation - consumed` per dimension. */
+	released: SubagentReservationAmounts,
+	/** How the decision was computed; the handler only ever reports conservatively. */
+	basis: Schema.Literals(["reserved-conservative"])
+}) {};
+const maxEventTextLength = 4096;
+const boundedEventText = (text) => text.length <= maxEventTextLength ? text : `${text.slice(0, 4095)}…`;
+const ErrorMessage = Schema.Struct({ message: Schema.String });
+const ErrorTag = Schema.Struct({ _tag: Schema.NonEmptyString });
+const errorMessageOf = (error) => Option.match(Schema.decodeUnknownOption(ErrorMessage)(error), {
+	onNone: () => String(error),
+	onSome: ({ message }) => message
+});
+const errorTagOf = (error) => Option.match(Schema.decodeUnknownOption(ErrorTag)(error), {
+	onNone: () => "UnknownError",
+	onSome: ({ _tag }) => _tag
+});
+const boundedErrorTag = (tag) => {
+	const nonEmpty = tag.length === 0 ? "UnknownError" : tag;
+	return nonEmpty.length <= 256 ? nonEmpty : nonEmpty.slice(0, 256);
+};
+/**
+* The coordinator's bounded projection of a failed/aborted child Settlement
+* result (S2 plan §1.6, D5): `{errorTag, message}`, never a raw Cause. The
+* fallback tolerates any other bounded shape without ever surfacing the raw
+* value beyond a tag and message.
+*/
+const ChildFailureProjection = Schema.Struct({
+	errorTag: Schema.NonEmptyString,
+	message: Schema.String
+});
+const childFailureProjectionOf = (encodedResult) => Option.match(Schema.decodeUnknownOption(ChildFailureProjection)(encodedResult), {
+	onNone: () => ({
+		errorTag: errorTagOf(encodedResult),
+		message: errorMessageOf(encodedResult)
+	}),
+	onSome: (projection) => projection
+});
+const zeroReservationAmounts = SubagentReservationAmounts.make({
+	turns: 0,
+	toolCalls: 0,
+	durationMillis: 0,
+	inputTokens: 0,
+	outputTokens: 0,
+	costMicrousd: 0,
+	resultBytes: 0
+});
+const encodeDurableAccounting = Schema.encodeEffect(SubagentDurableAccounting);
+const encodeProjectionFailure = Schema.encodeEffect(SubagentProjectionFailure);
+const encodeBudgetFailure = Schema.encodeEffect(SubagentBudgetExhausted);
+const encodeExecutionFailure = Schema.encodeEffect(SubagentExecutionFailure);
+const encodeGrant = Schema.encodeEffect(SubagentGrant);
+const encodeAllocationAmounts = Schema.encodeEffect(SubagentReservationAmounts);
+const toNatural = (value) => Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+const observedUsageFromDelta = (delta) => SubagentObservedUsage.make({
+	turns: delta.modelCalls,
+	toolCalls: toNatural(delta.toolCalls),
+	inputTokens: toNatural(delta.inputTokens),
+	outputTokens: toNatural(delta.outputTokens),
+	costMicrousd: toNatural(delta.costMicrousd)
+});
+/** A child that never started consumed nothing; observing zeros releases everything. */
+const neverStartedUsage = SubagentObservedUsage.make({
+	turns: 0,
+	toolCalls: 0,
+	durationMillis: 0,
+	inputTokens: 0,
+	outputTokens: 0,
+	costMicrousd: 0,
+	resultBytes: 0
+});
+/**
+* Finalizer-driven settlement: observe honest final usage, then release the
+* unused allocation exactly once. Runs on every handler exit path — success,
+* declared failure, interruption, and defect — through the reservation's
+* `Effect.acquireRelease`; a missing reservation after a successful reserve
+* is a ledger invariant violation and therefore a defect.
+*/
+const settleReservation = (reservations, reservationId, startedAt, conservative) => Effect.gen(function* () {
+	const started = yield* Ref.get(startedAt);
+	if (started === void 0) yield* reservations.observe(reservationId, neverStartedUsage);
+	else {
+		const now = yield* Clock.currentTimeMillis;
+		yield* reservations.observe(reservationId, SubagentObservedUsage.make({ durationMillis: Math.max(0, Math.floor(now - started)) }));
+	}
+	if (started !== void 0 && conservative !== void 0) {
+		const own = (yield* reservations.parentSnapshot(conservative.parentRunId)).reservations.find((entry) => entry.reservationId === reservationId);
+		if (own === void 0) return yield* Effect.die("Missing subtree reservation during finalization");
+		const additional = (key) => Math.max(0, conservative.allocation[key] - (own.observedConsumed[key] ?? 0));
+		yield* reservations.observe(reservationId, SubagentObservedUsage.make({
+			turns: additional("turns"),
+			toolCalls: additional("toolCalls"),
+			durationMillis: additional("durationMillis"),
+			inputTokens: additional("inputTokens"),
+			outputTokens: additional("outputTokens"),
+			costMicrousd: additional("costMicrousd"),
+			resultBytes: additional("resultBytes")
+		}));
+	}
+	yield* reservations.release(reservationId);
+}).pipe(Effect.orDie);
+/**
+* Module-private provenance wrapper (SUB-033 hardening): ONLY the operations
+* that can genuinely produce the engine signals wrap them here, so
+* containment classification never trusts the runtime identity of classes an
+* author could declare in their own failure Schema — a spoofed
+* `ToolCallWaiting` in author data is contained as data, never rethrown as a
+* suspension signal.
+*/
+var GenuineEngineSignal = class {
+	signal;
+	_tag = "GenuineEngineSignal";
+	constructor(signal) {
+		this.signal = signal;
+	}
+};
+const wrapEngineSignal = (signal) => new GenuineEngineSignal(signal);
+/**
+* Build the Toolkit handler Layer for one delegation Tool from a model Layer or
+* an explicit child Agent Binding.
+*
+* Construction requirements carry the child Binding's full runtime needs and
+* both projections; they are captured once via `Effect.context` so the
+* per-call handler requirements stay exactly the Tool's declared engine
+* dependencies. The handler dispatches on the engine-provided per-batch
+* `SubagentDurability` service mode:
+*
+* - **ephemeral** (the explicit engine default when no durable coordinator
+*   supplied `RunOptions.subagent`): the S1 path unchanged — preflight, an
+*   in-process scoped child Run (SUB-011/012), stable lifecycle events,
+*   total-mapped expected child failures, and Scope-finalizer reservation
+*   settlement on every exit path.
+* - **durable** (S2): the same fail-closed preflight and input projection,
+*   then idempotent establishment through the coordinator (spec §12 steps
+*   2-9) with construction-fixed child Binding digests, encoded grant, and
+*   encoded allocation; the engine-owned waiting signal while the attached
+*   child is nonterminal; and, on re-entry with a settled child, output
+*   decoding, `projectResult`, and ONE atomic settlement join carrying the
+*   conservative accounting summary. Failed children join as the bounded
+*   `SubagentExecutionFailure`; no in-process child fiber ever starts.
+*/
+const layer = (delegation, modelOrBinding, options = {}) => {
+	const childBinding = "definition" in modelOrBinding ? modelOrBinding : {
+		definition: delegation.target,
+		model: modelOrBinding
+	};
+	if (childBinding.definition !== delegation.target) throw new Error("Subagent.layer requires the delegation's exact target Definition");
+	const resolvePolicy = (spawner) => resolveSubagentPolicy(delegation, spawner.policy, options.parentCaps, spawner.depth === 0 && spawner.budget === void 0 ? "root-attached" : "conserved");
+	const toolkit = Toolkit.make(delegation.tool);
+	const contained = delegation.failureMode === "return";
+	const encodeChildInput = Schema.encodeEffect(delegation.target.input);
+	const encodeSuccess = Schema.encodeEffect(delegation.success);
+	const decodeChildOutput = Schema.decodeUnknownEffect(delegation.target.output);
+	const encodeResultProjectionFailure = Schema.encodeEffect(Schema.Union([delegation.failure, SubagentProjectionFailure]));
+	const childToolCallAllowance = (parameters, policy, childPolicy) => resolveToolCallAllowance(delegation.toolCallAllowance, parameters, policy, childPolicy);
+	const durableDeclaration = options.durable === void 0 ? void 0 : { targetDigests: {
+		agent: options.durable.targetDigests.agent,
+		model: options.durable.targetDigests.model,
+		tools: options.durable.targetDigests.tools
+	} };
+	const executionFailure = (classification, errorTag, message, child) => SubagentExecutionFailure.make({
+		delegationId: delegation.delegationId,
+		targetAgentId: delegation.target.id,
+		classification,
+		errorTag: boundedErrorTag(errorTag),
+		message: boundedEventText(message),
+		...child === void 0 ? {} : {
+			childThreadId: child.childThreadId,
+			childSubmissionId: child.childSubmissionId,
+			childRunId: child.childRunId
+		}
+	});
+	const prestartDenied = (reason, message) => SubagentPrestartDenied.make({
+		delegationId: delegation.delegationId,
+		targetAgentId: delegation.target.id,
+		reason,
+		message: boundedEventText(message)
+	});
+	const build = Effect.gen(function* () {
+		const captured = yield* Effect.context();
+		const invoke = Effect.fn(`SubagentRuntime.${delegation.name}`)(function* (parameters, handlerContext) {
+			const spawner = yield* AgentSpawner;
+			const resolved = resolvePolicy(spawner);
+			const { policy, childPolicy, allocation } = resolved;
+			const caps = spawner.budget === void 0 ? resolved.caps : residualSubagentCaps(resolved.caps, spawner.policy, spawner.budget, spawner.budgetScope === "worker-run");
+			const sink = yield* RunEventSink;
+			const reservations = yield* SubagentReservations;
+			const toolCallId = yield* Schema.decodeUnknownEffect(ToolCallId)(handlerContext.toolCallId).pipe(Effect.orDie);
+			const grant = narrowSubagentGrant(delegation.grant, spawner.grant);
+			const depth = spawner.depth + 1;
+			if (depth > grant.maxDepth) return yield* prestartDenied("nested-delegation", "Delegation exceeds the inherited depth ceiling");
+			if (!(spawner.grant?.childLifetimes ?? ["attached", "background"]).includes("attached")) return yield* prestartDenied("grant-violation", "The inherited grant does not permit attached children");
+			if (spawner.depth > 0 && spawner.budget === void 0) return yield* prestartDenied("budget-conflict", "Nested ephemeral delegation requires an inherited subtree reservation");
+			const prepared = yield* delegation.prepareInput(parameters, {
+				source: "tool",
+				delegationId: delegation.delegationId,
+				toolCallId,
+				parent: spawner.parent
+			});
+			const encodedInput = yield* encodeChildInput(prepared).pipe(Effect.mapError(() => SubagentProjectionFailure.make({
+				delegationId: delegation.delegationId,
+				stage: "input",
+				message: "Prepared child input did not satisfy the target Agent input Schema"
+			})));
+			const parentRunId = spawner.parent.runId;
+			yield* reservations.registerParent(parentRunId, caps).pipe(Effect.catchTag("SubagentParentBudgetConflict", () => Effect.fail(prestartDenied("budget-conflict", "The parent Run is already registered with different delegation caps; supply shared parentCaps explicitly"))));
+			const reservationId = makeBudgetReservationId(parentRunId, toolCallId);
+			const startedAt = yield* Ref.make(void 0);
+			yield* Effect.acquireRelease(reservations.reserve(SubagentReservationRequest.make({
+				parentRunId,
+				parentToolCallId: toolCallId,
+				allocation,
+				...policy.descendantInvocations === void 0 ? {} : { descendantInvocations: policy.descendantInvocations }
+			})).pipe(Effect.catchTags({
+				SubagentReservationConflict: (conflict) => Effect.die(conflict),
+				SubagentParentBudgetUnknown: (unknown) => Effect.die(unknown)
+			})), () => settleReservation(reservations, reservationId, startedAt, (policy.descendantInvocations ?? 0) > 0 ? {
+				parentRunId,
+				allocation
+			} : void 0));
+			yield* reservations.acquireChildSlot(parentRunId, 1 + (policy.descendantInvocations ?? 0)).pipe(Effect.catchTag("SubagentParentBudgetUnknown", (unknown) => Effect.die(unknown)));
+			const seededChild = options.child;
+			const seededBudget = seededChild?.budget;
+			const budget = {
+				guard: seededBudget === void 0 ? (effect) => effect : (effect) => seededBudget.guard(effect),
+				consume: (delta) => reservations.observe(reservationId, observedUsageFromDelta(delta)).pipe(Effect.orDie, Effect.andThen(seededBudget === void 0 ? Effect.void : seededBudget.consume(delta)))
+			};
+			const toolCallAllowance = childToolCallAllowance(parameters, policy, childPolicy);
+			const childOptions = {
+				...seededChild,
+				subagentGrant: grant,
+				delegationDepth: depth,
+				subagentBudget: SubagentBudgetReservation.make({
+					caps,
+					allocation,
+					...policy.descendantInvocations === void 0 ? {} : { descendantInvocations: policy.descendantInvocations }
+				}),
+				budget,
+				...toolCallAllowance === void 0 ? {} : { toolCallAllowance }
+			};
+			yield* Ref.set(startedAt, yield* Clock.currentTimeMillis);
+			const childScope = yield* Scope.make();
+			yield* Effect.addFinalizer((exit) => Scope.close(childScope, exit));
+			const child = yield* spawner.spawn({
+				...childBinding,
+				definition: {
+					...childBinding.definition,
+					policy: childPolicy
+				}
+			}, encodedInput, {
+				delegationId: delegation.delegationId,
+				parentToolCallId: toolCallId
+			}, childOptions).pipe(Scope.provide(childScope));
+			const payload = {
+				toolCallId,
+				delegationId: delegation.delegationId,
+				childThreadId: child.threadId,
+				childRunId: child.runId,
+				targetAgentId: delegation.target.id,
+				depth: child.parentLink.depth
+			};
+			const emit = (event) => sink.emit(event).pipe(Effect.orDie);
+			yield* emit({
+				_tag: "SubagentRequested",
+				...payload
+			});
+			yield* emit({
+				_tag: "SubagentStarted",
+				...payload
+			});
+			return yield* Effect.gen(function* () {
+				const result = yield* child.await.pipe(Effect.catch((childFailure) => child.usageReport.pipe(Effect.flatMap((report) => emit({
+					_tag: "SubagentFailed",
+					...payload,
+					...report,
+					errorTag: errorTagOf(childFailure),
+					message: boundedEventText(errorMessageOf(childFailure))
+				})), Effect.andThen(Effect.fail(options.mapChildFailure === void 0 ? executionFailure("child-failed", errorTagOf(childFailure), "The child Run failed") : options.mapChildFailure(childFailure))))), Effect.timeoutOrElse({
+					duration: Duration.millis(allocation.durationMillis),
+					orElse: () => Effect.succeed(void 0)
+				}), Effect.tapCause((cause) => Cause.hasDies(cause) ? child.usageReport.pipe(Effect.flatMap((report) => emit({
+					_tag: "SubagentFailed",
+					...payload,
+					...report,
+					errorTag: "Defect",
+					message: "The child Run ended with a defect"
+				})), Effect.ignore) : Effect.void));
+				if (result === void 0) {
+					yield* Scope.close(childScope, Exit.void);
+					const report = yield* child.usageReport;
+					yield* emit({
+						_tag: "SubagentFailed",
+						...payload,
+						...report,
+						errorTag: "SubagentBudgetExhausted",
+						message: `Attached child exceeded its ${allocation.durationMillis}ms delegation duration budget`
+					});
+					return yield* SubagentBudgetExhausted.make({
+						parentRunId,
+						dimension: "duration",
+						limitValue: allocation.durationMillis,
+						observedValue: allocation.durationMillis
+					});
+				}
+				const report = yield* child.usageReport;
+				yield* emit({
+					_tag: "SubagentCompleted",
+					...payload,
+					...report,
+					turns: result.turns,
+					finishReason: result.finishReason,
+					...result.exhausted !== void 0 ? { exhausted: result.exhausted } : {}
+				});
+				const projected = yield* delegation.projectResult(result.output, {
+					budgetExhausted: result.finishReason === "budget-exhausted",
+					...report
+				}, parameters);
+				const encodedResult = yield* encodeSuccess(projected).pipe(Effect.mapError(() => SubagentProjectionFailure.make({
+					delegationId: delegation.delegationId,
+					stage: "result",
+					message: "Projected child result did not satisfy the delegation success Schema"
+				})));
+				const resultBytes = utf8ByteLength(JSON.stringify(encodedResult) ?? "");
+				yield* reservations.observe(reservationId, SubagentObservedUsage.make({ resultBytes })).pipe(Effect.orDie);
+				if (policy.maxResultBytes !== void 0 && resultBytes > policy.maxResultBytes) {
+					yield* emit({
+						_tag: "SubagentFailed",
+						...payload,
+						...report,
+						errorTag: "SubagentBudgetExhausted",
+						message: `Projected child result of ${resultBytes} bytes exceeds the ${policy.maxResultBytes}-byte delegation budget`
+					});
+					return yield* SubagentBudgetExhausted.make({
+						parentRunId,
+						dimension: "result-bytes",
+						limitValue: policy.maxResultBytes,
+						observedValue: resultBytes
+					});
+				}
+				yield* emit({
+					_tag: "SubagentJoined",
+					...payload,
+					...report
+				});
+				return projected;
+			}).pipe(Effect.onInterrupt(() => Scope.close(childScope, Exit.void).pipe(Effect.andThen(child.usageReport), Effect.flatMap((report) => sink.emit({
+				_tag: "SubagentInterrupted",
+				...payload,
+				...report,
+				reason: "Parent Run interrupted the attached child before it settled"
+			})), Effect.ignore)));
+		});
+		/**
+		* Durable branch: establishment through the
+		* coordinator's idempotent protocol instead of an in-process spawn. No
+		* child fiber ever starts here, and the S1 in-memory reservation service
+		* is deliberately not consulted — its Scope-finalizer settlement
+		* contradicts a handler that exits with the waiting signal while the
+		* child keeps running; durable budget lives in the coordinator's fenced
+		* ledger reservation built from `encodedAllocation`.
+		*/
+		const invokeDurable = Effect.fn(`SubagentRuntime.${delegation.name}.durable`)(function* (parameters, handlerContext, durability) {
+			const spawner = yield* AgentSpawner;
+			const { policy, childPolicy, allocation, caps } = resolvePolicy(spawner);
+			const encodedAllocation = yield* encodeAllocationAmounts(allocation).pipe(Effect.orDie);
+			const conservativeAccounting = yield* encodeDurableAccounting(SubagentDurableAccounting.make({
+				allocation,
+				consumed: allocation,
+				released: zeroReservationAmounts,
+				basis: "reserved-conservative"
+			})).pipe(Effect.orDie);
+			const sink = yield* RunEventSink;
+			const toolCallId = yield* Schema.decodeUnknownEffect(ToolCallId)(handlerContext.toolCallId).pipe(Effect.orDie);
+			const emit = (event) => sink.emit(event).pipe(Effect.orDie);
+			const grant = narrowSubagentGrant(delegation.grant, spawner.grant);
+			const depth = spawner.depth + 1;
+			if (depth > grant.maxDepth) return yield* prestartDenied("nested-delegation", "Delegation exceeds the inherited depth ceiling");
+			if (!(spawner.grant?.childLifetimes ?? ["attached", "background"]).includes("attached")) return yield* prestartDenied("grant-violation", "The inherited grant does not permit attached children");
+			const encodedGrant = yield* encodeGrant(grant).pipe(Effect.orDie);
+			const prepared = yield* delegation.prepareInput(parameters, {
+				source: "tool",
+				delegationId: delegation.delegationId,
+				toolCallId,
+				parent: spawner.parent
+			});
+			const encodedInput = yield* encodeChildInput(prepared).pipe(Effect.mapError(() => SubagentProjectionFailure.make({
+				delegationId: delegation.delegationId,
+				stage: "input",
+				message: "Prepared child input did not satisfy the target Agent input Schema"
+			})));
+			const status = yield* Effect.mapError(wrapEngineSignal)(durability.establish({
+				toolCallId,
+				delegationId: delegation.delegationId,
+				target: delegation.target,
+				targetAgentId: delegation.target.id,
+				depth,
+				...durableDeclaration === void 0 ? {} : { targetDigests: durableDeclaration.targetDigests },
+				encodedChildInput: encodedInput,
+				encodedGrant,
+				encodedAllocation,
+				toolCallAllowance: childToolCallAllowance(parameters, policy, childPolicy),
+				policy: childPolicy,
+				budget: {
+					caps,
+					allocation,
+					...policy.descendantInvocations === void 0 ? {} : { descendantInvocations: policy.descendantInvocations }
+				}
+			}));
+			switch (status._tag) {
+				case "denied": return yield* executionFailure("establishment-denied", status.errorTag, status.message);
+				case "waiting": {
+					const payload = {
+						toolCallId,
+						delegationId: delegation.delegationId,
+						childThreadId: status.childThreadId,
+						childRunId: status.childRunId,
+						targetAgentId: delegation.target.id,
+						depth
+					};
+					yield* emit({
+						_tag: "SubagentRequested",
+						...payload
+					});
+					yield* emit({
+						_tag: "SubagentStarted",
+						...payload
+					});
+					return yield* Effect.mapError(wrapEngineSignal)(durability.waiting(toolCallId, status));
+				}
+				case "settled": {
+					const payload = {
+						toolCallId,
+						delegationId: delegation.delegationId,
+						childThreadId: status.childThreadId,
+						childRunId: status.childRunId,
+						targetAgentId: delegation.target.id,
+						depth
+					};
+					const report = RunUsageReport.make({
+						usage: status.usage ?? unknownRunTotals(),
+						delegatedUsage: status.delegatedUsage ?? unknownRunTotals()
+					});
+					const settleFailure = (failure, encodedFailure) => emit({
+						_tag: "SubagentFailed",
+						...payload,
+						...report,
+						errorTag: errorTagOf(failure),
+						message: boundedEventText(errorMessageOf(failure))
+					}).pipe(Effect.andThen(Effect.mapError(wrapEngineSignal)(durability.join({
+						toolCallId,
+						encodedResult: encodedFailure,
+						isFailure: !contained,
+						encodedAccounting: conservativeAccounting
+					}))), Effect.andThen(Effect.fail(failure)));
+					if (status.outcome !== "completed") {
+						const projection = childFailureProjectionOf(status.encodedResult);
+						const failure = executionFailure(status.outcome === "aborted" ? "child-aborted" : projection.errorTag === "ChildCompatibilityFailure" ? "child-compatibility" : "child-failed", projection.errorTag, projection.message, status);
+						return yield* settleFailure(failure, yield* encodeExecutionFailure(failure).pipe(Effect.orDie));
+					}
+					const decoded = yield* decodeChildOutput(status.encodedResult).pipe(Effect.catch(() => {
+						const failure = SubagentProjectionFailure.make({
+							delegationId: delegation.delegationId,
+							stage: "result",
+							message: "Settled child output did not satisfy the target Agent output Schema"
+						});
+						return encodeProjectionFailure(failure).pipe(Effect.orDie, Effect.flatMap((encodedFailure) => settleFailure(failure, encodedFailure)));
+					}));
+					const projected = yield* delegation.projectResult(decoded, {
+						budgetExhausted: status.finishReason === "budget-exhausted",
+						...report
+					}, parameters).pipe(Effect.catch((declared) => encodeResultProjectionFailure(declared).pipe(Effect.orDie, Effect.flatMap((encodedFailure) => settleFailure(declared, encodedFailure)))));
+					const encodedResult = yield* encodeSuccess(projected).pipe(Effect.catch(() => {
+						const failure = SubagentProjectionFailure.make({
+							delegationId: delegation.delegationId,
+							stage: "result",
+							message: "Projected child result did not satisfy the delegation success Schema"
+						});
+						return encodeProjectionFailure(failure).pipe(Effect.orDie, Effect.flatMap((encodedFailure) => settleFailure(failure, encodedFailure)));
+					}));
+					const resultBytes = utf8ByteLength(JSON.stringify(encodedResult) ?? "");
+					if (policy.maxResultBytes !== void 0 && resultBytes > policy.maxResultBytes) {
+						const failure = SubagentBudgetExhausted.make({
+							parentRunId: spawner.parent.runId,
+							dimension: "result-bytes",
+							limitValue: policy.maxResultBytes,
+							observedValue: resultBytes
+						});
+						return yield* settleFailure(failure, yield* encodeBudgetFailure(failure).pipe(Effect.orDie));
+					}
+					yield* Effect.mapError(wrapEngineSignal)(durability.join({
+						toolCallId,
+						encodedResult,
+						isFailure: false,
+						encodedAccounting: conservativeAccounting
+					}));
+					yield* emit({
+						_tag: "SubagentJoined",
+						...payload,
+						...report
+					});
+					return projected;
+				}
+			}
+		});
+		const containSignals = (failure) => failure instanceof GenuineEngineSignal ? Effect.fail(failure.signal) : Effect.succeed(failure);
+		const unwrapSignals = (failure) => failure instanceof GenuineEngineSignal ? failure.signal : failure;
+		const handlerImpl = (parameters, handlerContext) => Effect.gen(function* () {
+			const spawner = yield* AgentSpawner;
+			const sink = yield* RunEventSink;
+			const durability = yield* SubagentDurability;
+			if (durability.mode === "durable") {
+				const durable = invokeDurable(parameters, handlerContext, durability).pipe(Effect.scoped, Effect.provideService(AgentSpawner, spawner), Effect.provideService(RunEventSink, sink), Effect.provideService(SubagentDurability, durability), Effect.provide(captured));
+				return yield* contained ? durable.pipe(Effect.catch(containSignals)) : durable.pipe(Effect.mapError(unwrapSignals));
+			}
+			const ephemeral = invoke(parameters, handlerContext).pipe(Effect.scoped, Effect.provideService(AgentSpawner, spawner), Effect.provideService(RunEventSink, sink), Effect.provideService(SubagentDurability, durability), Effect.provide(captured));
+			return yield* contained ? ephemeral.pipe(Effect.catch(containSignals)) : ephemeral.pipe(Effect.mapError(unwrapSignals));
+		});
+		const handler = handlerImpl;
+		return { [delegation.name]: handler };
+	});
+	return toolkit.toLayer(build);
+};
+function background(targetOrDeclaration, selected) {
+	const declaration = "target" in targetOrDeclaration ? targetOrDeclaration : make(targetOrDeclaration.id, { target: targetOrDeclaration });
+	return background$1(declaration, selected);
+}
+//#endregion
+export { delegationCapsFromPolicy as C, delegationAllocationFromPolicy as S, reporting as _, define as a, SubagentPrestartDenied as b, Worker as c, cancel as d, followUp as f, start as g, observe as h, background as i, WorkerObservation as l, list as m, SubagentResult as n, layer as o, inspect as p, Subagent_exports as r, make as s, SubagentDurableAccounting as t, awaitWorker as u, reportingToWorker as v, SubagentProjectionFailure as x, SubagentPolicy as y };
+
+//# sourceMappingURL=Subagent-Cy_hU1tv.mjs.map