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

package/dist/Subagent-DyfzHNdv.d.mts

@@ -0,0 +1,826 @@
+import { d as ToolCallId, r as DelegationId, t as AgentId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { c as SubagentExecutionFailureClassification, d as SubagentReservationAmounts, l as SubagentGrant, o as SubagentDelegationCaps, s as SubagentExecutionFailure } from "./SubagentContract-DdT7Cqe6.mjs";
+import { SubagentBudgetExhausted, SubagentReservations } from "./capabilities/SubagentReservations.mjs";
+import { a as Receipt, n as JoinedToHost, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { s as RunTotals } from "./Usage-Dx0aknfk.mjs";
+import { t as ThreadHistory } from "./ThreadHistory-tS1KwxHR.mjs";
+import { T as RunDispositionDeclaration, _ as InstructionSource, c as Definition, m as InputPromptSource, r as AnyDefinition } from "./Agent-CN0EWRsR.mjs";
+import { a as WorkerError, c as WorkerRef, l as WorkerReport, n as WorkerBudgetScope, r as WorkerCompletion } from "./Worker-CaPYykpe.mjs";
+import { V as RunSubagentDigests, x as RunContextPreparation } from "./RunOptions-g1aigcKI.mjs";
+import { i as SubagentHost, l as WorkerReporting } from "./SubagentHost-CJUBQlcc.mjs";
+import { S as ToolCallWaiting, _ as SubagentDurability, b as SubagentDurabilityError, c as AgentSpawner, h as SpawnRunOptions, l as AgentSpawnerParent, o as AgentRuntimeFailure, p as RuntimeBinding, s as AgentRuntimeRequirements } from "./AgentRuntime-uxR_a4VM.mjs";
+import { t as RunEventSink } from "./RunEventSink-D5aVhISG.mjs";
+import { Tool, Toolkit } from "effect/unstable/ai";
+import { Crypto, Duration, Effect, Layer, Schema, Scope, Stream } from "effect";
+//#region src/capabilities/internal/subagent-contract.d.ts
+declare const SubagentPolicyFields: Schema.Struct<{
+  /** Total invocation slots, including reserved descendants, available through this delegation budget. */
+  readonly maxChildren: Schema.Int;
+  /** Concurrently executing children per parent Run. */
+  readonly maxConcurrency: Schema.Int;
+  /** Invocation slots held for the entire descendant subtree; omitted reserves zero. */
+  readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  /** Model turns reserved for each child invocation. */
+  readonly maxTurns: Schema.Int;
+  /** Tool Calls reserved for each child invocation. */
+  readonly maxToolCalls: Schema.Int;
+  /** Wall-clock duration reserved for each child invocation. */
+  readonly maxDuration: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly maxInputTokens: Schema.optionalKey<Schema.Int>;
+  readonly maxOutputTokens: Schema.optionalKey<Schema.Int>;
+  readonly maxCostMicrousd: Schema.optionalKey<Schema.Natural>;
+  readonly maxResultBytes: Schema.optionalKey<Schema.Int>;
+}>;
+type SubagentPolicyFields = typeof SubagentPolicyFields.Type;
+/** Inputs normalized and validated by `SubagentPolicy.make`. */
+type SubagentPolicyInput = Readonly<Omit<SubagentPolicyFields, "maxDuration"> & {
+  /** Finite, positive wall-clock duration accepted in any Effect Duration input form. */
+  readonly maxDuration: Duration.Input;
+}>;
+declare const SubagentPolicy_base: Schema.Class<SubagentPolicy, Schema.Struct<{
+  /** Total invocation slots, including reserved descendants, available through this delegation budget. */
+  readonly maxChildren: Schema.Int;
+  /** Concurrently executing children per parent Run. */
+  readonly maxConcurrency: Schema.Int;
+  /** Invocation slots held for the entire descendant subtree; omitted reserves zero. */
+  readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  /** Model turns reserved for each child invocation. */
+  readonly maxTurns: Schema.Int;
+  /** Tool Calls reserved for each child invocation. */
+  readonly maxToolCalls: Schema.Int;
+  /** Wall-clock duration reserved for each child invocation. */
+  readonly maxDuration: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly maxInputTokens: Schema.optionalKey<Schema.Int>;
+  readonly maxOutputTokens: Schema.optionalKey<Schema.Int>;
+  readonly maxCostMicrousd: Schema.optionalKey<Schema.Natural>;
+  readonly maxResultBytes: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/**
+ * 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.
+ */
+declare class SubagentPolicy extends SubagentPolicy_base {
+  /** Normalize and validate finite delegation bounds, throwing on invalid input. */
+  static make(input: SubagentPolicyInput): SubagentPolicy;
+}
+declare const SubagentPrestartDenied_base: Schema.Class<SubagentPrestartDenied, Schema.TaggedStruct<"SubagentPrestartDenied", {
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly reason: Schema.Literals<readonly ["nested-delegation", "grant-violation", "budget-conflict"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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.
+ */
+declare class SubagentPrestartDenied extends SubagentPrestartDenied_base {}
+declare const SubagentProjectionFailure_base: Schema.Class<SubagentProjectionFailure, Schema.TaggedStruct<"SubagentProjectionFailure", {
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly stage: Schema.Literals<readonly ["input", "result"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Input or result projection failed its Schema or bounds.
+ * Fail closed: the message is a fixed description and
+ * never carries the raw child value.
+ */
+declare class SubagentProjectionFailure extends SubagentProjectionFailure_base {}
+/**
+ * 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.
+ */
+declare const delegationCapsFromPolicy: (policy: SubagentPolicy) => SubagentDelegationCaps;
+/** Derive the all-or-nothing per-invocation reservation from one delegation policy. */
+declare const delegationAllocationFromPolicy: (policy: SubagentPolicy) => SubagentReservationAmounts;
+//#endregion
+//#region src/capabilities/internal/subagent-background.d.ts
+type Declaration<Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project> = Pick<SubagentDefineOptions<Input, Output, unknown, Record<string, Tool.Any>, Parameters, Success, Failure, Prepare, Project>, "parameters" | "success" | "failure" | "prepareInput" | "projectResult" | "policy" | "toolCallAllowance" | "needsApproval"> & {
+  readonly name: Name;
+  readonly delegationId: WorkerRef["delegationId"];
+  readonly target: AnyDefinition & {
+    readonly input: Input;
+    readonly output: Output;
+  };
+  readonly grant: SubagentGrant;
+};
+type WorkerDeclaration<Name extends string> = {
+  readonly name: Name;
+  readonly delegationId: WorkerRef["delegationId"];
+  readonly target: Pick<AnyDefinition, "id">;
+};
+/** Portable identity checked against this declaration; possession grants no authority. */
+declare const Worker: <const Name extends string>(declaration: WorkerDeclaration<Name>) => Schema.brand<Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>, `@effect-agent/Worker/${Name}`>;
+type Worker<Name extends string> = ReturnType<typeof Worker<Name>>["Type"];
+/** Observes one exact Receipt. Terminal failure data never includes raw child output. */
+declare const WorkerObservation: <Success extends Schema.Top>(success: Success) => Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Pending">;
+  readonly receipt: typeof Receipt;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Settled">;
+  readonly receipt: typeof Receipt;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literal<"completed">;
+  readonly result: Success;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Settled">;
+  readonly receipt: typeof Receipt;
+  readonly runId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+  readonly failure: typeof SubagentExecutionFailure;
+}>]>;
+type WorkerObservation<Success extends Schema.Top> = ReturnType<typeof WorkerObservation<Success>>["Type"];
+declare const operations: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>) => {
+  start: (parameters: Parameters["Type"], options: {
+    readonly idempotencyKey: IdempotencyKey;
+    readonly budgetScope?: WorkerBudgetScope;
+  }) => Effect.Effect<{
+    worker: {
+      readonly schemaVersion: 1;
+      readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+      readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>;
+    receipt: Receipt;
+  }, SubagentPrestartDenied | SubagentProjectionFailure | WorkerError | Failure["Type"], Prepare | SubagentHost | Parameters["EncodingServices"] | (Schema.Top & Input)["EncodingServices"]>;
+  followUp: (worker: {
+    readonly schemaVersion: 1;
+    readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+    readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>, parameters: Parameters["Type"], options: {
+    readonly idempotencyKey: IdempotencyKey;
+  }) => Effect.Effect<Receipt, SubagentProjectionFailure | WorkerError | Failure["Type"], Prepare | SubagentHost | Parameters["EncodingServices"] | (Schema.Top & Input)["EncodingServices"]>;
+  observe: (operation: "await" | "inspect", worker: {
+    readonly schemaVersion: 1;
+    readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+    readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>, receipt: Receipt) => Effect.Effect<{
+    readonly _tag: "Pending";
+    readonly receipt: Receipt;
+  } | {
+    readonly _tag: "Settled";
+    readonly receipt: Receipt;
+    readonly runId?: (string & import("effect/Brand").Brand<"@effect-agent/core/RunId">) | undefined;
+    readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+    readonly outcome: "aborted" | "failed";
+    readonly failure: SubagentExecutionFailure;
+  } | Schema.Struct.View<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literal<"completed">;
+    readonly result: Success;
+  }, "Type", Success extends {
+    readonly "~type.optionality": "optional";
+  } ? "result" : never, Success extends {
+    readonly "~type.mutability": "mutable";
+  } ? "result" : never>, SubagentProjectionFailure | WorkerError | Failure["Type"], Project | SubagentHost | Output["DecodingServices"] | Parameters["DecodingServices"] | Success["EncodingServices"]>;
+  list: (options?: {
+    readonly limit?: number;
+    readonly after?: ThreadId;
+  } | undefined) => Effect.Effect<{
+    items: {
+      state: "active" | "idle" | "starting";
+      worker: {
+        readonly schemaVersion: 1;
+        readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+        readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+        readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+      } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>;
+      latestReceipt: Receipt | null;
+    }[];
+    next: (string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">) | null;
+  }, WorkerError, SubagentHost>;
+  cancel: (worker: {
+    readonly schemaVersion: 1;
+    readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+    readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>, receipt: Receipt) => Effect.Effect<void, JoinedToHost | WorkerError, SubagentHost>;
+};
+/** Start a host-managed worker. Retrying the same explicit key reuses the accepted input. */
+declare const start: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, parameters: Parameters["Type"], options: {
+  readonly idempotencyKey: IdempotencyKey;
+  readonly budgetScope?: WorkerBudgetScope;
+}) => Effect.Effect<{
+  worker: {
+    readonly schemaVersion: 1;
+    readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+    readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>;
+  receipt: Receipt;
+}, SubagentPrestartDenied | SubagentProjectionFailure | WorkerError | Failure["Type"], Prepare | SubagentHost | Parameters["EncodingServices"] | (Schema.Top & Input)["EncodingServices"]>;
+/** Admit typed follow-up parameters to the same worker Thread. */
+declare const followUp: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, worker: Worker<Name>, parameters: Parameters["Type"], options: {
+  readonly idempotencyKey: IdempotencyKey;
+}) => Effect.Effect<Receipt, SubagentProjectionFailure | WorkerError | Failure["Type"], Prepare | SubagentHost | Parameters["EncodingServices"] | (Schema.Top & Input)["EncodingServices"]>;
+/** Inspect a continuing worker with the same summary contract returned by list. */
+declare const summary: <const Name extends string>(declaration: WorkerDeclaration<Name> & {
+  readonly target: AnyDefinition;
+}, worker: Worker<Name>) => Effect.Effect<{
+  latestReceipt: Receipt | null;
+  state: "active" | "idle" | "starting";
+  worker: {
+    readonly schemaVersion: 1;
+    readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+    readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+    readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>;
+}, WorkerError, SubagentHost>;
+/** Inspect the worker, or pass a Receipt to observe that exact accepted input. */
+declare function inspect<const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, worker: Worker<Name>): ReturnType<typeof summary<Name>>;
+declare function inspect<const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, worker: Worker<Name>, receipt: Receipt): ReturnType<ReturnType<typeof operations<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>>["observe"]>;
+/** Read an authorized finite history snapshot; pass the last emitted sequence to resume. */
+declare const observe: <const Name extends string>(declaration: WorkerDeclaration<Name> & {
+  readonly target: AnyDefinition;
+}, worker: Worker<Name>, options?: {
+  readonly after?: number;
+}) => Stream.Stream<{
+  readonly sequence: number;
+  readonly recordId: string;
+  readonly record: Schema.Json;
+}, WorkerError, SubagentHost>;
+/** Wait for the exact Receipt. Interrupting this Effect never cancels accepted work. */
+declare const awaitWorker: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, worker: Worker<Name>, receipt: Receipt) => Effect.Effect<{
+  readonly _tag: "Pending";
+  readonly receipt: Receipt;
+} | {
+  readonly _tag: "Settled";
+  readonly receipt: Receipt;
+  readonly runId?: (string & import("effect/Brand").Brand<"@effect-agent/core/RunId">) | undefined;
+  readonly settlementId: string & import("effect/Brand").Brand<"@effect-agent/core/SettlementId">;
+  readonly outcome: "aborted" | "failed";
+  readonly failure: SubagentExecutionFailure;
+} | Schema.Struct.View<{
+  readonly _tag: Schema.Literal<"Settled">;
+  readonly receipt: typeof Receipt;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literal<"completed">;
+  readonly result: Success;
+}, "Type", Success extends {
+  readonly "~type.optionality": "optional";
+} ? "result" : never, Success extends {
+  readonly "~type.mutability": "mutable";
+} ? "result" : never>, SubagentProjectionFailure | WorkerError | Failure["Type"], Project | SubagentHost | Output["DecodingServices"] | Parameters["DecodingServices"] | Success["EncodingServices"]>;
+/** List only workers visible through the caller-bound host facet. */
+declare const list: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, options?: {
+  readonly limit?: number;
+  readonly after?: ThreadId;
+}) => Effect.Effect<{
+  items: {
+    state: "active" | "idle" | "starting";
+    worker: {
+      readonly schemaVersion: 1;
+      readonly delegationId: string & import("effect/Brand").Brand<"@effect-agent/core/DelegationId">;
+      readonly targetAgentId: string & import("effect/Brand").Brand<"@effect-agent/core/AgentId">;
+      readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+    } & import("effect/Types").UnionToIntersection<`@effect-agent/Worker/${Name}` extends (infer T) ? T extends `@effect-agent/Worker/${Name}` ? T extends (infer U extends string) ? import("effect/Brand").Brand<U> : never : never : never>;
+    latestReceipt: Receipt | null;
+  }[];
+  next: (string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">) | null;
+}, WorkerError, SubagentHost>;
+/** Request cancellation of exactly one Receipt; JoinedToHost remains a typed conflict. */
+declare const cancel: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, worker: Worker<Name>, receipt: Receipt) => Effect.Effect<void, JoinedToHost | WorkerError, SubagentHost>;
+/** Opt in to each model-facing operation. Waiting remains programmatic only. */
+interface BackgroundOptions {
+  /** Deliver a standard completion, or use an optional application input mapper. */
+  readonly reportToParent?: true | WorkerReporting<unknown, unknown>;
+  readonly start?: true;
+  readonly followUp?: true;
+  readonly inspect?: true;
+  readonly summary?: true;
+  readonly list?: true;
+  readonly cancel?: true;
+  /** Author-owned funding request for starts; every native admission separately authorizes it. */
+  readonly budgetScope?: WorkerBudgetScope;
+}
+type Operation = Exclude<keyof BackgroundOptions, "budgetScope" | "reportToParent">;
+type Suffix = {
+  start: "start";
+  followUp: "follow_up";
+  inspect: "inspect";
+  summary: "summary";
+  list: "list";
+  cancel: "cancel";
+};
+declare const ReceiptParameters: <Name extends string>(declaration: WorkerDeclaration<Name>) => Schema.Struct<{
+  readonly worker: Schema.brand<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>, `@effect-agent/Worker/${Name}`>;
+  readonly receipt: typeof Receipt;
+}>;
+declare const WorkerParameters: <Name extends string>(declaration: WorkerDeclaration<Name>) => Schema.Struct<{
+  readonly worker: Schema.brand<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>, `@effect-agent/Worker/${Name}`>;
+}>;
+declare const Summary: <Name extends string>(declaration: WorkerDeclaration<Name>) => Schema.Struct<{
+  readonly worker: Schema.brand<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>, `@effect-agent/Worker/${Name}`>;
+  readonly latestReceipt: Schema.NullOr<typeof Receipt>;
+  readonly state: Schema.Literals<readonly ["starting", "active", "idle"]>;
+}>;
+declare const FollowUpParameters: <Name extends string, Parameters extends Schema.Top>(declaration: WorkerDeclaration<Name>, parameters: Parameters) => Schema.Struct<{
+  readonly worker: Schema.brand<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>, `@effect-agent/Worker/${Name}`>;
+  readonly parameters: Parameters;
+}>;
+declare const ListParameters: Schema.Struct<{
+  readonly limit: Schema.optionalKey<Schema.Int>;
+  readonly after: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+}>;
+declare const Started: <Name extends string>(declaration: WorkerDeclaration<Name>) => Schema.Struct<{
+  readonly worker: Schema.brand<Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>, `@effect-agent/Worker/${Name}`>;
+  readonly receipt: typeof Receipt;
+}>;
+declare const Page: <Name extends string>(declaration: WorkerDeclaration<Name>) => Schema.Struct<{
+  readonly items: Schema.$Array<Schema.Struct<{
+    readonly worker: Schema.brand<Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>, `@effect-agent/Worker/${Name}`>;
+    readonly latestReceipt: Schema.NullOr<typeof Receipt>;
+    readonly state: Schema.Literals<readonly ["starting", "active", "idle"]>;
+  }>>;
+  readonly next: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+}>;
+declare const preparationFailure: <Failure extends Schema.Top>(failure: Failure) => Schema.Union<readonly [Failure, typeof SubagentProjectionFailure, typeof WorkerError]>;
+declare const startFailure: <Failure extends Schema.Top>(failure: Failure) => Schema.Union<readonly [Failure, typeof SubagentProjectionFailure, typeof SubagentPrestartDenied, typeof WorkerError]>;
+declare const cancelFailure: Schema.Union<readonly [typeof WorkerError, typeof JoinedToHost]>;
+type ToolSchemas<Name extends string, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top> = {
+  start: {
+    parameters: Parameters;
+    success: ReturnType<typeof Started<Name>>;
+    failure: ReturnType<typeof startFailure<Failure>>;
+  };
+  followUp: {
+    parameters: ReturnType<typeof FollowUpParameters<Name, Parameters>>;
+    success: typeof Receipt;
+    failure: ReturnType<typeof preparationFailure<Failure>>;
+  };
+  inspect: {
+    parameters: ReturnType<typeof ReceiptParameters<Name>>;
+    success: ReturnType<typeof WorkerObservation<Success>>;
+    failure: ReturnType<typeof preparationFailure<Failure>>;
+  };
+  summary: {
+    parameters: ReturnType<typeof WorkerParameters<Name>>;
+    success: ReturnType<typeof Summary<Name>>;
+    failure: typeof WorkerError;
+  };
+  list: {
+    parameters: typeof ListParameters;
+    success: ReturnType<typeof Page<Name>>;
+    failure: typeof WorkerError;
+  };
+  cancel: {
+    parameters: ReturnType<typeof ReceiptParameters<Name>>;
+    success: typeof Schema.Void;
+    failure: typeof cancelFailure;
+  };
+};
+type BackgroundToolMap<Name extends string, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top> = {
+  start: Tool.Tool<`${Name}_start`, ToolSchemas<Name, Parameters, Success, Failure>["start"] & {
+    readonly failureMode: "error";
+  }, SubagentHost | Crypto.Crypto>;
+  followUp: Tool.Tool<`${Name}_follow_up`, ToolSchemas<Name, Parameters, Success, Failure>["followUp"] & {
+    readonly failureMode: "error";
+  }, SubagentHost | Crypto.Crypto>;
+  inspect: Tool.Tool<`${Name}_inspect`, ToolSchemas<Name, Parameters, Success, Failure>["inspect"] & {
+    readonly failureMode: "error";
+  }, SubagentHost>;
+  summary: Tool.Tool<`${Name}_summary`, ToolSchemas<Name, Parameters, Success, Failure>["summary"] & {
+    readonly failureMode: "error";
+  }, SubagentHost>;
+  list: Tool.Tool<`${Name}_list`, ToolSchemas<Name, Parameters, Success, Failure>["list"] & {
+    readonly failureMode: "error";
+  }, SubagentHost>;
+  cancel: Tool.Tool<`${Name}_cancel`, ToolSchemas<Name, Parameters, Success, Failure>["cancel"] & {
+    readonly failureMode: "error";
+  }, SubagentHost>;
+};
+/**
+ * Native Tool names and schemas expose statically guaranteed selections. The handler Layer also
+ * requires services for operations whose conditional flags may enable them at runtime.
+ */
+type BackgroundTools<Name extends string, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Selected extends BackgroundOptions> = { readonly [Op in Operation as Selected[Op] extends true ? `${Name}_${Suffix[Op]}` : never]: BackgroundToolMap<Name, Parameters, Success, Failure>[Op]; };
+/**
+ * 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.
+ */
+declare const background$1: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project, const Selected extends BackgroundOptions>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, selected: Selected) => Readonly<{
+  tools: BackgroundTools<Name, Parameters, Success, Failure, Selected>;
+  toolkit: Toolkit.Toolkit<BackgroundTools<Name, Parameters, Success, Failure, Selected>>;
+  layer: Layer.Layer<Tool.HandlersFor<BackgroundTools<Name, Parameters, Success, Failure, Selected>>, never, (Selected["reportToParent"] extends (infer T) ? T extends Selected["reportToParent"] ? T extends true ? Exclude<Project, Scope.Scope> | Exclude<Output["DecodingServices"], Scope.Scope> | Exclude<Parameters["DecodingServices"], Scope.Scope> | Exclude<Success["EncodingServices"], Scope.Scope> : T extends WorkerReporting<infer _E, infer R> ? Exclude<R, Scope.Scope> : never : never : never) | (Selected["followUp"] extends (infer T_1) ? T_1 extends Selected["followUp"] ? T_1 extends true ? Prepare | Input["EncodingServices"] | Parameters["EncodingServices"] : never : never : never) | (Selected["inspect"] extends (infer T_2) ? T_2 extends Selected["inspect"] ? T_2 extends true ? Project | Output["DecodingServices"] | Parameters["DecodingServices"] | Success["EncodingServices"] : never : never : never) | (Selected["start"] extends (infer T_3) ? T_3 extends Selected["start"] ? T_3 extends true ? Prepare | Input["EncodingServices"] | Parameters["EncodingServices"] : never : never : never)>;
+}>;
+//#endregion
+//#region src/capabilities/internal/subagent-reporting.d.ts
+/**
+ * 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.
+ */
+declare const reporting: <const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project, CoordinatorInput extends Schema.Top, ReportFailure extends Schema.Top = typeof Schema.Never, ReportRequirements = never>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, options: {
+  readonly input: CoordinatorInput;
+  readonly failure?: ReportFailure;
+  readonly prepare: (report: WorkerReport<Success>) => Effect.Effect<CoordinatorInput["Type"], ReportFailure["Type"], ReportRequirements>;
+}) => WorkerReporting<Failure["Type"] | ReportFailure["Type"], Parameters["DecodingServices"] | Output["DecodingServices"] | Success["EncodingServices"] | CoordinatorInput["EncodingServices"] | Project | ReportRequirements>;
+/**
+ * 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.
+ */
+declare const reportingToWorker: <E, R, const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project>(report: WorkerReporting<E, R>, destination: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>) => WorkerReporting<E | Failure["Type"], R | Prepare | Parameters["DecodingServices"] | Input["EncodingServices"]>;
+declare namespace Subagent_d_exports {
+  export { BackgroundOptions, BackgroundTools, SubagentChildRunFailure, SubagentContainedFailure, SubagentDeclarationOptions, SubagentDefineOptions, SubagentDelegation, SubagentDurableAccounting, SubagentDurableOptions, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentFailureMode, SubagentGrant, SubagentLayerRequirements, SubagentPolicy, SubagentPolicyInput, SubagentPrepareContext, SubagentPrestartDenied, SubagentProjectionFailure, SubagentResult, SubagentResultContext, SubagentReturnModeFailure, SubagentRuntimeOptions, SubagentTool, SubagentToolFailure, SubagentTools, Worker, WorkerCompletion, WorkerObservation, WorkerReport, awaitWorker as await, background, cancel, define, delegationAllocationFromPolicy, delegationCapsFromPolicy, followUp, inspect, layer, list, make, observe, reporting, reportingToWorker, start };
+}
+/**
+ * Bounded parent metadata visible to `prepareInput`.
+ * It never contains the parent transcript, prompt, or a root runtime Context.
+ */
+type SubagentPrepareContext = {
+  readonly delegationId: DelegationId;
+} & ({
+  readonly source: "tool";
+  readonly toolCallId: ToolCallId;
+  readonly parent: AgentSpawnerParent;
+} | {
+  readonly source: "programmatic";
+  readonly parent: Pick<AgentSpawnerParent, "agentId" | "threadId">;
+});
+/**
+ * Bounded framework context handed to `projectResult` (SUB-034).
+ * `budgetExhausted` is true exactly when the child settled through the
+ * final-answer exhaustion resolution (RUN-018) — on the ephemeral path from
+ * the child result's `finishReason`, on the durable path from the child
+ * Settlement's honest marker — so the projection can surface a
+ * budget-truncated partial to the orchestrator.
+ */
+interface SubagentResultContext {
+  readonly budgetExhausted: boolean;
+  /** Own and disjoint attached-descendant usage; absent only for legacy/custom hosts. */
+  readonly usage?: RunTotals;
+  readonly delegatedUsage?: RunTotals;
+}
+/** Default delegation result, preserving partial-output information. */
+declare const SubagentResult: <Output extends Schema.Top>(output: Output) => Schema.Struct<{
+  readonly output: Output;
+  readonly budgetExhausted: Schema.Boolean;
+}>;
+type SubagentResult<Output extends Schema.Top> = ReturnType<typeof SubagentResult<Output>>;
+/**
+ * The delegation Tool failure Schema: the author's declared failure plus the
+ * framework's preflight/budget/projection/durable-execution failure family.
+ * With the default `failureMode: "error"`, exactly
+ * this union (plus Effect AI's own error) can enter the parent handler `E`.
+ *
+ * The engine-owned `ToolCallWaiting` suspension signal and the typed
+ * `SubagentDurabilityError` are members so the durable branch's waiting
+ * signal and coordinator-seam failures travel typed through
+ * `failureMode: "error"` (S2 plan §2); neither ever reaches an ephemeral
+ * caller, and a waiting signal is not a Tool failure — the batch executor
+ * keeps the raising call open and suspends the Run.
+ */
+type SubagentToolFailure<Failure extends Schema.Top> = Schema.Union<readonly [Failure, typeof SubagentPrestartDenied, typeof SubagentBudgetExhausted, typeof SubagentProjectionFailure, typeof SubagentExecutionFailure, typeof ToolCallWaiting, typeof SubagentDurabilityError]>;
+/**
+ * Resolution for expected delegation failures (SUB-033, ADR-0019 S2).
+ * `"error"` (the default) keeps today's semantics: every expected failure
+ * travels the Effect error channel and fails the parent Tool batch (D-008).
+ * `"return"` contains them: the declared child failure and the framework
+ * failure family become model-visible result data instead of parent-fatal
+ * errors, so one dead child cannot detonate the whole parent Run.
+ *
+ * Effect AI's native `failureMode: "return"` is deliberately NOT used: its
+ * `Stream.catch` converts every handler failure into a result, which would
+ * encode the engine-owned `ToolCallWaiting` suspension signal as data and
+ * silently orphan a durable child. Containment therefore lives in the
+ * delegation handler — the underlying Tool keeps Effect AI
+ * `failureMode: "error"`, the Tool success Schema widens to a union of the
+ * declared success and the contained failure family, and exactly
+ * `ToolCallWaiting` and `SubagentDurabilityError` stay in the error channel,
+ * preserving durable suspension semantics by construction.
+ */
+type SubagentFailureMode = "error" | "return";
+/**
+ * The failure family that becomes model-visible result data under
+ * `failureMode: "return"`: the author-declared failure plus every expected
+ * framework delegation failure. The engine-signal members are excluded by
+ * construction.
+ */
+type SubagentContainedFailure<Failure extends Schema.Top> = Schema.Union<readonly [Failure, typeof SubagentPrestartDenied, typeof SubagentBudgetExhausted, typeof SubagentProjectionFailure, typeof SubagentExecutionFailure]>;
+/**
+ * The only failures a `"return"`-mode delegation Tool can raise: the
+ * engine-owned waiting signal (consumed by the batch executor, never a Tool
+ * failure) and the durable coordinator-seam error. Neither ever reaches an
+ * ephemeral caller.
+ */
+type SubagentReturnModeFailure = Schema.Union<readonly [typeof ToolCallWaiting, typeof SubagentDurabilityError]>;
+/**
+ * The native Effect AI Tool created by `Subagent.make` (SUB-001, SUB-003).
+ * Its per-call dependencies are exactly the engine-provided `AgentSpawner`,
+ * `RunEventSink`, and `SubagentDurability`; every child
+ * requirement except the inherited Thread history policy is a construction requirement
+ * of `Subagent.layer`. The engine excludes its own per-batch services from the runtime's
+ * public requirements. Runtime IDs use the overridable default reference.
+ */
+type SubagentTool<Name extends string, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Mode extends SubagentFailureMode = "error"> = Mode extends "return" ? Tool.Tool<Name, {
+  readonly parameters: Parameters;
+  readonly success: Schema.Union<readonly [Success, SubagentContainedFailure<Failure>]>;
+  readonly failure: SubagentReturnModeFailure;
+  readonly failureMode: "error";
+}, AgentSpawner | RunEventSink | SubagentDurability> : Tool.Tool<Name, {
+  readonly parameters: Parameters;
+  readonly success: Success;
+  readonly failure: SubagentToolFailure<Failure>;
+  readonly failureMode: "error";
+}, AgentSpawner | RunEventSink | SubagentDurability>;
+/** Singleton Tool record provided by one `Subagent.layer`. */
+type SubagentTools<Name extends string, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Mode extends SubagentFailureMode = "error"> = { readonly [Key in Name]: SubagentTool<Name, Parameters, Success, Failure, Mode>; };
+/** Explicit options accepted by `Subagent.make`. */
+interface SubagentDefineOptions<TargetInput extends Schema.Top, TargetOutput extends Schema.Top, TargetInstructions, TargetTools extends Record<string, Tool.Any>, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, PrepareRequirements = never, ProjectRequirements = never, Mode extends SubagentFailureMode = "error"> {
+  /**
+   * Expected-failure resolution (SUB-033): `"error"` (default) fails the
+   * parent Tool batch; `"return"` contains the declared failure and the
+   * framework failure family as model-visible result data while
+   * `ToolCallWaiting`/`SubagentDurabilityError` stay in the error channel.
+   */
+  readonly failureMode?: Mode;
+  /** Model-visible description of the delegated capability. */
+  readonly description?: string | undefined;
+  /** The model-agnostic child Agent Definition this delegation targets (SUB-002). */
+  readonly target: Definition<TargetInput, TargetOutput, TargetInstructions, Toolkit.Toolkit<TargetTools>, RunDispositionDeclaration<TargetOutput["Type"], Schema.Top> | undefined, unknown, Schema.Top | undefined>;
+  /** Schema for the model-decoded delegation parameters. */
+  readonly parameters: Parameters;
+  /** Schema for the bounded parent Tool result. */
+  readonly success: Success;
+  /** Schema for the author-declared delegation failure data. */
+  readonly failure: Failure;
+  /**
+   * Effectful, typed projection from decoded parameters and bounded parent
+   * metadata to the child Agent input. It never
+   * receives the parent transcript or a root Context; its expected failures
+   * are already the declared Tool failure.
+   */
+  readonly prepareInput: (parameters: Parameters["Type"], context: SubagentPrepareContext) => Effect.Effect<TargetInput["Type"], Failure["Type"] | SubagentProjectionFailure, PrepareRequirements>;
+  /**
+   * Bounded result projection from the Schema-decoded child output, result
+   * context, and original Schema-decoded Tool parameters to the declared Tool
+   * success value. This is the explicit
+   * declassification boundary for child output: the parameters let it bind
+   * echoed identity and scope to the exact request without prompt parsing.
+   * The context carries the
+   * framework's honest exhaustion marker (SUB-034): when `budgetExhausted` is
+   * true the child settled through the final-answer resolution (RUN-018) and
+   * its output is a budget-truncated partial — surface it in the declared
+   * success Schema so the orchestrator can decide to re-delegate with a
+   * raised `toolCallAllowance`.
+   */
+  readonly projectResult: (output: TargetOutput["Type"], context: SubagentResultContext, parameters: Parameters["Type"]) => Effect.Effect<Success["Type"], Failure["Type"] | SubagentProjectionFailure, ProjectRequirements>;
+  /**
+   * Per-invocation child Tool Call allowance (SUB-034): a tightening-only
+   * bound below the child Definition's own `maxToolCalls`, additionally
+   * clamped to this delegation's `SubagentPolicy.maxToolCalls` (the
+   * per-invocation reservation slice). `fromParameters` lets the orchestrator
+   * model grant a larger allowance through an author-owned parameter field —
+   * the budget-extension flow is a fresh re-delegation with a raised
+   * allowance, never a mid-flight top-up. Durable establishment records the
+   * effective allowance before child admission and restores it on every Attempt.
+   */
+  readonly toolCallAllowance?: {
+    /** Applied when `fromParameters` is absent or yields nothing. */
+    readonly default: number;
+    /** Extract the model-granted allowance from the decoded parameters. */
+    readonly fromParameters?: (parameters: Parameters["Type"]) => number | undefined;
+  } | undefined;
+  /** Per-child ceilings. When omitted, reserve from the parent policy's shared delegation pool. */
+  readonly policy?: SubagentPolicy | undefined;
+  /**
+   * Authority ceiling for the child. Defaults to
+   * exactly the target's declared Tool names at depth ceiling one. The engine
+   * exposes only permitted Tools; nested launches also require depth and lifetime authority.
+   */
+  readonly grant?: SubagentGrant | undefined;
+  /**
+   * Native Effect AI approval metadata for establishment only (SUB-026):
+   * parent approval never authorizes child actions, siblings, or retries.
+   */
+  readonly needsApproval?: Tool.NeedsApproval<Parameters> | undefined;
+}
+/**
+ * An immutable Subagent capability: one target Agent Definition exposed to
+ * a parent as one Effect AI Tool with explicit projections, policy, and
+ * authority ceiling. It owns no acquired resources and
+ * is not executable until `Subagent.layer` supplies the child's model Layer.
+ */
+interface SubagentDelegation<Name extends string, TargetInput extends Schema.Top, TargetOutput extends Schema.Top, TargetInstructions, TargetTools extends Record<string, Tool.Any>, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, PrepareRequirements = never, ProjectRequirements = never, Mode extends SubagentFailureMode = "error"> extends SubagentDefineOptions<TargetInput, TargetOutput, TargetInstructions, TargetTools, Parameters, Success, Failure, PrepareRequirements, ProjectRequirements, Mode> {
+  readonly name: Name;
+  /** Stable delegation identity; S1 derives it from the unique Tool name. */
+  readonly delegationId: DelegationId;
+  readonly grant: SubagentGrant;
+  /** The resolved expected-failure resolution (SUB-033); never absent after `make`. */
+  readonly failureMode: Mode;
+  /**
+   * The canonical contained-failure family for this delegation (SUB-033):
+   * the declared failure plus the framework members. Consumers that classify
+   * returned failure data (for example a coverage gate) MUST decode through
+   * this value rather than reconstructing the union, so a framework change
+   * to the contained family can never diverge from their decoder.
+   */
+  readonly containedFailure: SubagentContainedFailure<Failure>;
+  /** The real Effect AI Tool to include in the parent Toolkit (SUB-001). */
+  readonly tool: SubagentTool<Name, Parameters, Success, Failure, Mode>;
+}
+/** Pure Subagent authoring surface. */
+/** Optional authoring fields; schemas default to the child's input and result envelope. */
+type SubagentDeclarationOptions<Input extends Schema.Top, Output extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project, Mode extends SubagentFailureMode> = Omit<SubagentDefineOptions<Input, Output, Instructions, Tools, Parameters, Success, Failure, Prepare, Project, Mode>, "parameters" | "success" | "failure" | "prepareInput" | "projectResult"> & {
+  readonly parameters?: Parameters;
+  readonly success?: Success;
+  readonly failure?: Failure;
+  readonly prepareInput?: SubagentDefineOptions<Input, Output, Instructions, Tools, Parameters, Success, Failure, Prepare, Project, Mode>["prepareInput"];
+  readonly projectResult?: SubagentDefineOptions<Input, Output, Instructions, Tools, Parameters, Success, Failure, Prepare, Project, Mode>["projectResult"];
+};
+/**
+ * Expose one child Agent as an attached Effect AI Tool. The nonempty application
+ * name is preserved as both Tool name and delegation identity; no prefix is required.
+ * Parameters and result projections default to the child's input and result envelope.
+ * Throws when the name is empty. Nested Tool visibility follows the effective inherited grant.
+ */
+declare function make<const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, Parameters extends Schema.Top = Input, Success extends Schema.Top = SubagentResult<Output>, Failure extends Schema.Top = typeof Schema.Never, Prepare = never, Project = never, Target extends Definition<Input, Output, Instructions, Toolkit.Toolkit<Tools>, RunDispositionDeclaration<Output["Type"], Schema.Top> | undefined, unknown, Schema.Top | undefined> = Definition<Input, Output, Instructions, Toolkit.Toolkit<Tools>, RunDispositionDeclaration<Output["Type"], Schema.Top> | undefined, unknown, Schema.Top | undefined>>(name: Name, options: SubagentDeclarationOptions<Input, Output, Instructions, Tools, Parameters, Success, Failure, Prepare, Project, "return"> & {
+  readonly failureMode: "return";
+  readonly target: Target;
+}): SubagentDelegation<Name, Input, Output, Instructions, Tools, Parameters, Success, Failure, Prepare, Project, "return"> & {
+  readonly target: Target;
+};
+declare function make<const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, Parameters extends Schema.Top = Input, Success extends Schema.Top = SubagentResult<Output>, Failure extends Schema.Top = typeof Schema.Never, Prepare = never, Project = never, Target extends Definition<Input, Output, Instructions, Toolkit.Toolkit<Tools>, RunDispositionDeclaration<Output["Type"], Schema.Top> | undefined, unknown, Schema.Top | undefined> = Definition<Input, Output, Instructions, Toolkit.Toolkit<Tools>, RunDispositionDeclaration<Output["Type"], Schema.Top> | undefined, unknown, Schema.Top | undefined>>(name: Name, options: SubagentDeclarationOptions<Input, Output, Instructions, Tools, Parameters, Success, Failure, Prepare, Project, "error"> & {
+  readonly target: Target;
+}): SubagentDelegation<Name, Input, Output, Instructions, Tools, Parameters, Success, Failure, Prepare, Project> & {
+  readonly target: Target;
+};
+/** @deprecated Use `Subagent.make`. */
+declare const define: typeof make;
+type InstructionResultOf<Instructions, Input> = Instructions extends ((input: Input) => infer Result) ? Result : Instructions;
+type InstructionErrorOf<Instructions, Input> = InstructionResultOf<Instructions, Input> extends Effect.Effect<infer _Success, infer Error, infer _Requirements> ? Error : never;
+type InstructionRequirementsOf<Instructions, Input> = InstructionResultOf<Instructions, Input> extends Effect.Effect<infer _Success, infer _Error, infer Requirements> ? Requirements : never;
+/**
+ * Every expected child Run failure the delegation's total mapping must cover:
+ * the child's inferred Agent failures plus
+ * the interpreter's policy, protocol, and approval failures. Interruption and
+ * defects are not members; they retain their distinct semantics.
+ */
+type SubagentChildRunFailure<TargetInput extends Schema.Top, TargetOutput extends Schema.Top, TargetInstructions, TargetTools extends Record<string, Tool.Any>, Provider, ModelProvides, ModelRequires, InstructionError = InstructionErrorOf<TargetInstructions, TargetInput["Type"]>, InstructionRequirements = InstructionRequirementsOf<TargetInstructions, TargetInput["Type"]>, InputPromptValue extends InputPromptSource<TargetInput["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined, RunDispositionValue extends RunDispositionDeclaration<TargetOutput["Type"], Schema.Top> | undefined = undefined> = AgentRuntimeFailure<RuntimeBinding<TargetInput, TargetOutput, TargetInstructions, TargetTools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, never, InstructionError>;
+/**
+ * Construction requirements of one `Subagent.layer`: the child
+ * Binding's full runtime requirements (Model Layer requirements, child Tool
+ * handlers and their services, Schema services), both projection
+ * requirements, and the parent-owned reservation service. Nothing here leaks
+ * into the per-call Tool handler requirements. ThreadHistory and RunContextPreparation belong
+ * to the parent Run's AgentSpawner and are inherited at invocation rather than captured here.
+ */
+type SubagentLayerRequirements<TargetInput extends Schema.Top, TargetOutput extends Schema.Top, TargetInstructions, TargetTools extends Record<string, Tool.Any>, Provider, ModelProvides, ModelRequires, PrepareRequirements, ProjectRequirements, HookRequirements = never, InstructionError = InstructionErrorOf<TargetInstructions, TargetInput["Type"]>, InstructionRequirements = InstructionRequirementsOf<TargetInstructions, TargetInput["Type"]>, InputPromptValue extends InputPromptSource<TargetInput["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined, RunDispositionValue extends RunDispositionDeclaration<TargetOutput["Type"], Schema.Top> | undefined = undefined> = Exclude<AgentRuntimeRequirements<RuntimeBinding<TargetInput, TargetOutput, TargetInstructions, TargetTools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, HookRequirements, InstructionRequirements>, ThreadHistory | RunContextPreparation> | TargetInput["EncodingServices"] | PrepareRequirements | ProjectRequirements | SubagentReservations;
+/**
+ * Optional construction-fixed digest override for durable delegation.
+ * The coordinator normally resolves the exact target Definition through its
+ * existing host registration. An override must agree with that registration.
+ */
+interface SubagentDurableOptions {
+  /**
+   * Exact digests from the target's host registration. Fixed once at handler
+   * Layer construction and checked against that registration at establishment.
+   * Recovery uses the canonical request's recorded digests, never current code.
+   */
+  readonly targetDigests: RunSubagentDigests;
+}
+declare const SubagentDurableAccounting_base: Schema.Class<SubagentDurableAccounting, Schema.Struct<{
+  /** The per-invocation allocation reserved at establishment. */
+  readonly allocation: typeof SubagentReservationAmounts;
+  /** Final consumed decision per dimension. */
+  readonly consumed: typeof SubagentReservationAmounts;
+  /** Amounts returned to the parent: `allocation - consumed` per dimension. */
+  readonly released: typeof SubagentReservationAmounts;
+  /** How the decision was computed; the handler only ever reports conservatively. */
+  readonly basis: Schema.Literals<readonly ["reserved-conservative"]>;
+}>, {}>;
+/**
+ * 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).
+ */
+declare class SubagentDurableAccounting extends SubagentDurableAccounting_base {}
+/** Options accepted by `Subagent.layer`. */
+interface SubagentRuntimeOptions<Failure extends Schema.Top, ChildFailure, HookRequirements = never> {
+  /**
+   * Optional exact digest override. Without it, the durable coordinator resolves
+   * the target Definition from its existing host registrations.
+   */
+  readonly durable?: SubagentDurableOptions | undefined;
+  /**
+   * Total mapping from every expected child Run failure to the declared Tool
+   * failure (SUB-028). The parameter type is the child Binding's complete
+   * expected failure union, so a mapping that covers only part of it is a
+   * compile error. Interruption stays interruption and defects stay defects;
+   * neither reaches this mapping.
+   * When omitted, failures become bounded `SubagentExecutionFailure` values.
+   */
+  readonly mapChildFailure?: ((failure: ChildFailure) => Failure["Type"]) | undefined;
+  /**
+   * Override the parent-Run delegation caps registered with
+   * `SubagentReservations`. An explicit policy uses `delegationCapsFromPolicy(policy)`;
+   * an omitted policy uses one pool sized from the parent policy.
+   * Supply shared caps explicitly when one parent Run uses several delegation
+   * Tools, because re-registering different caps denies start fail-closed.
+   */
+  readonly parentCaps?: SubagentDelegationCaps | undefined;
+  /**
+   * Seed child Run options (approval, context, input hooks) so child actions
+   * follow their own ordinary approval and policy (SUB-026). Hook failures
+   * must be handled inside the hook (`never` in `E`); a supplied budget hook
+   * is composed after the reservation's own usage observation.
+   */
+  readonly child?: SpawnRunOptions<never, HookRequirements> | undefined;
+}
+/**
+ * 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.
+ */
+declare const layer: <Name extends string, TargetInput extends Schema.Top, TargetOutput extends Schema.Top, TargetInstructions, TargetTools extends Record<string, Tool.Any>, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, PrepareRequirements, ProjectRequirements, Provider, ModelProvides, ModelRequires, HookRequirements = never, Mode extends SubagentFailureMode = "error", InstructionError = InstructionErrorOf<TargetInstructions, TargetInput["Type"]>, InstructionRequirements = InstructionRequirementsOf<TargetInstructions, TargetInput["Type"]>, InputPromptValue extends InputPromptSource<TargetInput["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined, RunDispositionValue extends RunDispositionDeclaration<TargetOutput["Type"], Schema.Top> | undefined = undefined>(delegation: SubagentDelegation<Name, TargetInput, TargetOutput, TargetInstructions, TargetTools, Parameters, Success, Failure, PrepareRequirements, ProjectRequirements, Mode> & {
+  readonly target: {
+    readonly instructions: InstructionSource<TargetInput["Type"], NoInfer<InstructionError>, NoInfer<InstructionRequirements>>;
+    readonly inputPrompt?: InputPromptValue | undefined;
+    readonly updates?: UpdatesSchema | undefined;
+    readonly runDisposition?: RunDispositionValue | undefined;
+  };
+}, modelOrBinding: RuntimeBinding<TargetInput, TargetOutput, TargetInstructions, TargetTools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema> | RuntimeBinding<TargetInput, TargetOutput, TargetInstructions, TargetTools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>["model"], options?: SubagentRuntimeOptions<Failure, SubagentChildRunFailure<TargetInput, TargetOutput, TargetInstructions, TargetTools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, InputPromptValue, UpdatesSchema, RunDispositionValue>, HookRequirements>) => Layer.Layer<Tool.HandlersFor<SubagentTools<Name, Parameters, Success, Failure, Mode>>, never, SubagentLayerRequirements<TargetInput, TargetOutput, TargetInstructions, TargetTools, Provider, ModelProvides, ModelRequires, PrepareRequirements, ProjectRequirements, HookRequirements, InstructionError, InstructionRequirements, InputPromptValue, UpdatesSchema, RunDispositionValue>>;
+/**
+ * Derive selected background Tools directly from a child Agent, using its ID as the delegation
+ * name and its input/output Schemas as the default contract. Pass an explicit Subagent.make
+ * declaration to customize the name, projections, grants, or policy bounds.
+ */
+declare function background<const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, const Selected extends BackgroundOptions>(target: Definition<Input, Output, Instructions, Toolkit.Toolkit<Tools>, RunDispositionDeclaration<Output["Type"], Schema.Top> | undefined, unknown, Schema.Top | undefined> & {
+  readonly id: AgentId & Name;
+}, selected: Selected): ReturnType<typeof background$1<Name, Input, Output, Input, SubagentResult<Output>, typeof Schema.Never, never, never, Selected>>;
+declare function background<const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project, const Selected extends BackgroundOptions>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, selected: Selected): ReturnType<typeof background$1<Name, Input, Output, Parameters, Success, Failure, Prepare, Project, Selected>>;
+//#endregion
+export { cancel as A, delegationAllocationFromPolicy as B, reporting as C, Worker as D, BackgroundTools as E, start as F, SubagentPolicy as I, SubagentPolicyInput as L, inspect as M, list as N, WorkerObservation as O, observe as P, SubagentPrestartDenied as R, make as S, BackgroundOptions as T, delegationCapsFromPolicy as V, SubagentTools as _, SubagentDelegation as a, define as b, SubagentFailureMode as c, SubagentResult as d, SubagentResultContext as f, SubagentToolFailure as g, SubagentTool as h, SubagentDefineOptions as i, followUp as j, awaitWorker as k, SubagentLayerRequirements as l, SubagentRuntimeOptions as m, SubagentContainedFailure as n, SubagentDurableAccounting as o, SubagentReturnModeFailure as p, SubagentDeclarationOptions as r, SubagentDurableOptions as s, SubagentChildRunFailure as t, SubagentPrepareContext as u, Subagent_d_exports as v, reportingToWorker as w, layer as x, background as y, SubagentProjectionFailure as z };
+//# sourceMappingURL=Subagent-DyfzHNdv.d.mts.map