effect-agent 0.1.0-beta.12 → 0.1.0-beta.121

package/dist/Subagent-DCrB7an7.mjs

@@ -0,0 +1,1498 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from "./core/Identifiers.mjs";
+import { n as utf8ByteLength } from "./utf8-DchGZRBd.mjs";
+import { AgentPolicy } from "./core/AgentPolicy.mjs";
+import { IdempotencyKey, JoinedToHost, Receipt } from "./core/Receipt.mjs";
+import { i as Failure, o as Value } from "./FailureDiagnostic-BElLOoED.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 { C as MessageStatus, S as MessageRef, _ as WorkerStop, c as WorkerError, d as WorkerPage, f as WorkerRef, g as WorkerStarted, o as WorkerCompletion, p as WorkerReport, s as WorkerContext, v as WorkerStopped, y as WorkerSummary } from "./Worker-CfwzMZEK.mjs";
+import { BackgroundReporting, SubagentHost, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
+import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-Cp1hAb-W.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,
+	/** Original validation error; detailed diagnostics are never part of the safe message. */
+	cause: Schema.optionalKey(Value),
+	stack: Schema.optionalKey(Schema.String)
+}) {};
+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
+	};
+});
+/** Project a canonical child outcome into the bounded standard completion message. */
+const automaticReporting = (declaration) => ({
+	delegationId: declaration.delegationId,
+	target: declaration.target,
+	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 { message: yield* Schema.decodeEffect(WorkerCompletion)({
+			_tag: "WorkerCompletion",
+			schemaVersion: 1,
+			report: encoded,
+			budgetExhausted: report.observation.budgetExhausted
+		}).pipe(Effect.mapError(() => WorkerReportPreparationFailure.make({ stage: "projection" }))) };
+	})
+});
+//#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}`));
+/** Model-facing projection deliberately excludes operator-private diagnostics. */
+const toolObservation = (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
+	})
+]);
+/** One exact Receipt, including private canonical failure evidence for programmatic callers. */
+const WorkerObservation = (success) => {
+	const projected = toolObservation(success);
+	return Schema.Union([
+		projected.members[0],
+		projected.members[1],
+		Schema.Struct({
+			...projected.members[2].fields,
+			diagnostic: Schema.optionalKey(Failure)
+		})
+	]);
+};
+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, cause) => SubagentProjectionFailure.make({
+		delegationId: declaration.delegationId,
+		stage,
+		...cause === void 0 ? {} : { cause },
+		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((cause) => WorkerError.make({
+		operation,
+		reason: "worker-mismatch",
+		cause
+	})));
+	const validateReceipt = (worker, receipt, operation) => Schema.decodeEffect(Receipt.check(Schema.makeFilter((value) => value.threadId === worker.threadId)))(receipt).pipe(Effect.mapError((cause) => WorkerError.make({
+		operation,
+		reason: "receipt-mismatch",
+		cause
+	})));
+	const validateDelivery = Effect.fn("Subagent.validateWorkerDelivery")(function* (worker, delivery, operation) {
+		const validated = yield* Schema.decodeEffect(MessageStatus)(delivery).pipe(Effect.mapError((cause) => WorkerError.make({
+			operation,
+			reason: "corrupt",
+			cause
+		})));
+		if (validated.receipt !== null) yield* validateReceipt(worker, validated.receipt, operation);
+		return validated;
+	});
+	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",
+		cause: error
+	})));
+	const prepare = Effect.fn("Subagent.prepareWorkerInput")(function* (parameters, caller) {
+		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 yield* Schema.encodeEffect(declaration.target.input)(input).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
+	});
+	const validateKey = (key, operation) => Schema.decodeEffect(IdempotencyKey)(key).pipe(Effect.mapError((cause) => WorkerError.make({
+		operation,
+		reason: "idempotency-conflict",
+		cause
+	})));
+	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 encodedParameters = yield* Schema.encodeEffect(declaration.parameters)(parameters).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
+			const encodedGrant = yield* Schema.encodeEffect(SubagentGrant)(grant).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
+			const started = yield* service.start({
+				delegationId: declaration.delegationId,
+				target: declaration.target,
+				idempotencyKey: key,
+				encodedParameters,
+				encodedGrant,
+				...options.budgetScope === void 0 ? {} : { budgetScope: options.budgetScope },
+				prepare: Effect.gen(function* () {
+					const encodedInput = yield* prepare(parameters, caller);
+					const effectiveTarget = yield* service.resolveTargetPolicy({
+						target: declaration.target,
+						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);
+					return {
+						encodedInput,
+						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((cause) => WorkerError.make({
+				operation: "start",
+				reason: "corrupt",
+				cause
+			})));
+			if (validated.delivery.message.ownerThreadId !== caller.source.threadId) return yield* WorkerError.make({
+				operation: "start",
+				reason: "message-mismatch"
+			});
+			return {
+				worker: yield* validateWorker(validated.worker, "start"),
+				delivery: validated.delivery
+			};
+		}),
+		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 encodedParameters = yield* Schema.encodeEffect(declaration.parameters)(parameters).pipe(Effect.mapError((cause) => projectionFailure("input", cause)));
+			const delivery = yield* validateDelivery(validated, yield* service.followUp({
+				encodedParameters,
+				prepare: prepare(parameters, caller).pipe(Effect.map((encodedInput) => ({ encodedInput }))),
+				worker: validated,
+				target: declaration.target,
+				idempotencyKey: key
+			}), "followUp");
+			if (delivery.message.ownerThreadId !== caller.source.threadId) return yield* WorkerError.make({
+				operation: "followUp",
+				reason: "message-mismatch"
+			});
+			return delivery;
+		}),
+		inspectMessage: Effect.fn("Subagent.inspectWorkerMessage")(function* (worker, message) {
+			const service = yield* host;
+			const validated = yield* validateWorker(worker, "inspect");
+			const requested = yield* Schema.decodeEffect(MessageRef)(message).pipe(Effect.mapError((cause) => WorkerError.make({
+				operation: "inspect",
+				reason: "message-mismatch",
+				cause
+			})));
+			const observed = yield* service.inspect({
+				worker: validated,
+				target: declaration.target,
+				message: requested
+			});
+			if (!("message" in observed)) return yield* WorkerError.make({
+				operation: "inspect",
+				reason: "corrupt"
+			});
+			const delivery = yield* validateDelivery(validated, observed, "inspect");
+			if (!Schema.toEquivalence(MessageRef)(delivery.message, requested)) return yield* WorkerError.make({
+				operation: "inspect",
+				reason: "message-mismatch"
+			});
+			return delivery;
+		}),
+		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
+			});
+			if (!("_tag" in observed)) return yield* WorkerError.make({
+				operation,
+				reason: "corrupt"
+			});
+			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((cause) => WorkerError.make({
+					operation,
+					reason: "corrupt",
+					cause
+				}))) },
+				settlementId: yield* Schema.decodeEffect(SettlementId)(observed.settlementId).pipe(Effect.mapError((cause) => WorkerError.make({
+					operation,
+					reason: "corrupt",
+					cause
+				})))
+			};
+			if (observed.outcome === "failed" || observed.outcome === "aborted") return {
+				...base,
+				outcome: observed.outcome,
+				...observed.diagnostic === void 0 ? {} : { diagnostic: yield* Schema.decodeEffect(Failure)(observed.diagnostic).pipe(Effect.mapError((cause) => WorkerError.make({
+					operation,
+					reason: "corrupt",
+					cause
+				}))) },
+				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((cause) => projectionFailure("result", cause)));
+			const output = yield* Schema.decodeUnknownEffect(declaration.target.output)(observed.encodedResult).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
+			const result = yield* declaration.projectResult(output, { budgetExhausted: observed.budgetExhausted }, parameters);
+			const encoded = yield* Schema.encodeEffect(declaration.success)(result).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
+			const json = yield* Schema.decodeUnknownEffect(Schema.Json)(encoded).pipe(Effect.mapError((cause) => projectionFailure("result", cause)));
+			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((cause) => projectionFailure("result", cause)));
+		}),
+		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
+			});
+		})
+	};
+};
+/** Retain a first worker input. The same explicit key reuses its durable delivery identity. */
+const start = (declaration, parameters, options) => operations(declaration).start(parameters, options);
+/** Retain typed follow-up parameters for the same worker Thread; inspect its MessageRef for delivery. */
+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, reference) {
+	return reference === void 0 ? summary(declaration, worker) : "messageId" in reference ? operations(declaration).inspectMessage(worker, reference) : operations(declaration).observe("inspect", worker, reference);
+}
+/** 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 }
+	});
+}));
+/** Seal a continuing worker, retaining a stable command identity across retries and Runs. */
+const stop = (declaration, worker, options) => Effect.gen(function* () {
+	const service = yield* host;
+	const command = yield* Schema.decodeEffect(WorkerStop)({
+		worker,
+		...options
+	}).pipe(Effect.mapError((cause) => WorkerError.make({
+		operation: "stop",
+		reason: "corrupt",
+		cause
+	})));
+	if (worker.delegationId !== declaration.delegationId || worker.targetAgentId !== declaration.target.id) return yield* WorkerError.make({
+		operation: "stop",
+		reason: "worker-mismatch"
+	});
+	return yield* service.stop({
+		...command,
+		target: declaration.target
+	}).pipe(Effect.flatMap(Schema.decodeEffect(WorkerStopped)), Effect.mapError((cause) => Schema.is(WorkerError)(cause) ? cause : WorkerError.make({
+		operation: "stop",
+		reason: "corrupt",
+		cause
+	})));
+});
+/** 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 InspectParameters = (declaration) => Schema.Struct({
+	worker: Worker(declaration),
+	message: Schema.optionalKey(MessageRef),
+	receipt: Schema.optionalKey(Receipt)
+}).check(Schema.makeFilter(({ message, receipt }) => message === void 0 !== (receipt === void 0), { message: "Provide exactly one retained message reference or accepted receipt" }));
+const Inspection = (success) => Schema.Union([MessageStatus, toolObservation(success)]);
+const WorkerParameters = (declaration) => Schema.Struct({ worker: Worker(declaration) });
+const Summary = (declaration) => Schema.Struct({
+	...WorkerSummary.fields,
+	worker: Worker(declaration)
+});
+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),
+	delivery: MessageStatus
+}).check(Schema.makeFilter(({ worker, delivery }) => delivery.receipt === null || worker.threadId === delivery.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) : void 0;
+	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: `Retain input for a background ${declaration.name} worker and return its delivery state. Pending confirms retention only; inspect the same message instead of starting another worker.`,
+		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: `Retain typed follow-up input for an existing ${declaration.name} worker. Pending is retained, not executed: inspect the same message instead of sending the command again.`,
+		parameters: FollowUpParameters(declaration, declaration.parameters),
+		success: MessageStatus,
+		failure
+	}).annotate(WorkerOperationTool, true).addDependency(SubagentHost).addDependency(Crypto.Crypto);
+	const inspectTool = Tool.make(`${declaration.name}_inspect`, {
+		description: `Inspect one ${declaration.name} delivery by message reference, or its execution result by accepted receipt. Provide exactly one reference; inspection never resends input.`,
+		parameters: InspectParameters(declaration),
+		success: Inspection(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;
+				if (parameters.message !== void 0) return yield* ops.inspectMessage(parameters.worker, parameters.message);
+				if (parameters.receipt === void 0) return yield* WorkerError.make({
+					operation: "inspect",
+					reason: "message-mismatch"
+				});
+				return yield* ops.observe("inspect", parameters.worker, parameters.receipt).pipe(Effect.map((observed) => {
+					if ("diagnostic" in observed) {
+						const { diagnostic: _diagnostic, ...projected } = observed;
+						return projected;
+					}
+					return observed;
+				}), 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,
+	start: () => start,
+	stop: () => stop
+});
+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);
+function layer(delegation, modelOrBinding, options = {}) {
+	const childBinding = modelOrBinding !== void 0 && "definition" in modelOrBinding ? modelOrBinding : {
+		definition: delegation.target,
+		model: modelOrBinding ?? Layer.effectContext(Effect.context())
+	};
+	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 S, stop as _, define as a, SubagentProjectionFailure 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, SubagentPolicy as v, delegationAllocationFromPolicy as x, SubagentPrestartDenied as y };
+
+//# sourceMappingURL=Subagent-DCrB7an7.mjs.map