effect-agent 0.1.0-beta.164 → 0.1.0-beta.165

package/dist/{RunOptions-BHmBa05n.d.mts → RunOptions-CkSZSuIh.d.mts}

@@ -1,20 +1,24 @@
 import { d as ToolCallId, f as TurnId, l as SubmissionId, o as ReceiptId, r as DelegationId, s as RunId, t as AgentId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
-import { f as ToolExecutionKind, i as SubagentBudgetReservation, l as SubagentGrant, n as DelegationDepth, u as SubagentParentLink } from "./SubagentContract-tyN9v-Jv.mjs";
-import { i as UpdateError, r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
-import { c as Selection, l as Snapshot } from "./ToolExposure-r2eOWk4F.mjs";
-import { r as ModelCallUsage, s as RunTotals, t as ChildRunUsage } from "./Usage-BNjPR7Zr.mjs";
-import { a as AgentInputError, u as AgentToolAuthorizationCheckError } from "./AgentError-Bn1ytXRD.mjs";
-import { t as ToolParameterRejection } from "./ToolResult-BKdqWRff.mjs";
-import { t as AgentPolicy } from "./AgentPolicy-B4oH8TbG.mjs";
-import { r as AnyDefinition } from "./Agent-ZfnNCQXs.mjs";
+import { f as ToolExecutionKind, i as SubagentBudgetReservation, l as SubagentGrant, n as DelegationDepth, u as SubagentParentLink } from "./SubagentContract-DdPzxYQj.mjs";
+import { i as UpdateError, r as Update } from "./AgentUpdates-DksV4D0A.mjs";
+import { c as Selection, l as Snapshot } from "./ToolExposure-Ckg3-sTf.mjs";
+import { r as ModelCallUsage, s as RunTotals, t as ChildRunUsage } from "./Usage-CzZJ6A2n.mjs";
+import { a as AgentInputError, u as AgentToolAuthorizationCheckError } from "./AgentError-BMqPzIVt.mjs";
+import { t as ToolParameterRejection } from "./ToolResult-DqyEhJLF.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-CclAEpHn.mjs";
+import { r as AnyDefinition } from "./Agent-D0fbFT2d.mjs";
 import { o as MemoryRecallError } from "./MemoryReference-B8Q3UJoJ.mjs";
-import { t as RunPolicyUsage } from "./RunPolicyUsage-CUudVtg_.mjs";
-import { a as WorkerBudgetScope, r as FrameworkMessage } from "./Worker-XEBYxRQv.mjs";
-import { c as ModelCallContext, r as ContextRolloverSelection } from "./ContextWindow-DRQ5Mbm2.mjs";
-import { c as ContextMessageTokenEstimator, n as CompactionError } from "./ContextCompactor-BoKQOjr5.mjs";
-import { l as ToolExecutionClassValue, o as RunStepHook } from "./DurableStep-Cry_iol4.mjs";
+import { t as RunPolicyUsage } from "./RunPolicyUsage-QmYVw9z8.mjs";
+import { a as WorkerBudgetScope, r as FrameworkMessage } from "./Worker-DH5SAVIK.mjs";
+import { c as ModelCallContext, r as ContextRolloverSelection } from "./ContextWindow-aGZOPIPq.mjs";
+import { c as ContextMessageTokenEstimator, n as CompactionError } from "./ContextCompactor-DLpX-HUG.mjs";
+import { l as ToolExecutionClassValue, o as RunStepHook } from "./DurableStep-CTqx6DOV.mjs";
+import * as Schema$1 from "effect/Schema";
+import * as Context$1 from "effect/Context";
+import * as Effect$1 from "effect/Effect";
+import * as Layer$1 from "effect/Layer";
+import { Cause, DateTime } from "effect";
 import { LanguageModel, Model, Prompt, Response } from "effect/unstable/ai";
-import { Cause, Context, DateTime, Effect, Layer, Schema } from "effect";
 declare namespace RunOptions_d_exports {
   export { AgentUpdateAcceptance, ChildEstablishDenied, ChildEstablishSettled, ChildEstablishStatus, ChildEstablishWaiting, CommandDrainPolicy, CurrentToolFailureObserver, ModelToolFailure, ModelUsageAccounting, PreparedRunContext, ProgrammaticPreflightFailure, ProgrammaticToolFailure, ResolvedModelCall, RunApprovalDecision, RunApprovalHook, RunApprovalRequest, RunBudgetHook, RunBufferLimits, RunCompactionCommit, RunContextHook, RunContextPreparation, RunContextPreparationError, RunContextPreparationPassthrough, RunContextRequest, RunCostEstimate, RunCostEstimateRequest, RunCostEstimateValue, RunCostEstimator, RunDurabilityHook, RunInputCommand, RunInputHook, RunOptions, RunOptionsError, RunOptionsRequirements, RunResumeUsage, RunResumeUsageSchema, RunSchedulingHook, RunSchedulingOverride, RunSubagentChildIdentity, RunSubagentDigests, RunSubagentEstablishRequest, RunSubagentHook, RunSubagentJoinRequest, RunToolAuthorization, RunToolAuthorizationDecision, RunToolAuthorizationHook, RunToolAuthorizationRequest, RunToolCallDescriptor, RunToolFailureObserver, RunToolScheduling, RunTransientContextHook, RunTurnResponseCommit, RunTurnResume, RunTurnResumeCall, RunTurnResumeSettledCall, RunTurnResumeSettledCallSchema, RunTurnUsage, RunUsageDelta, ToolFailureObservation, toolFailureObserverLayer };
 }
@@ -90,14 +94,14 @@ type ToolFailureObservation = ModelToolFailure | ProgrammaticToolFailure | Progr
  * Never reenter ToolBroker, RunEventSink, or Agent execution, or intentionally self-interrupt.
  */
 interface RunToolFailureObserver {
-  readonly observe: (observation: ToolFailureObservation) => Effect.Effect<void>;
+  readonly observe: (observation: ToolFailureObservation) => Effect$1.Effect<void>;
 }
 /** Resolved once per Run; durable coordinators capture it at Layer acquisition. Default absent. */
-declare const CurrentToolFailureObserver: Context.Reference<RunToolFailureObserver | undefined>;
+declare const CurrentToolFailureObserver: Context$1.Reference<RunToolFailureObserver | undefined>;
 /** The sole installation seam, shared by ephemeral Runs and durable platform options. */
-declare const toolFailureObserverLayer: (observer: RunToolFailureObserver) => Layer.Layer<never>;
+declare const toolFailureObserverLayer: (observer: RunToolFailureObserver) => Layer$1.Layer<never>;
 /** Number of queued inputs consumed at one documented Turn seam. */
-declare const CommandDrainPolicy: Schema.Literals<readonly ["one", "all"]>;
+declare const CommandDrainPolicy: Schema$1.Literals<readonly ["one", "all"]>;
 type CommandDrainPolicy = typeof CommandDrainPolicy.Type;
 /** Engine-normalized input command. Capability packages may adapt richer audit records to it. */
 interface RunInputCommand {
@@ -118,10 +122,10 @@ interface RunInputHook<Error = never, Requirements = never> {
    * authority and retain any claimed input for `drain`, even when this wait is interrupted.
    * Used only with `restartOnJoinedInput`; each wait belongs to the model stream's Scope.
    */
-  readonly awaitJoin?: Effect.Effect<void, Error, Requirements> | undefined;
-  readonly start?: (() => Effect.Effect<void, Error, Requirements>) | undefined;
-  readonly drain: (policy: CommandDrainPolicy) => Effect.Effect<ReadonlyArray<RunInputCommand>, Error, Requirements>;
-  readonly end?: (() => Effect.Effect<void, never, Requirements>) | undefined;
+  readonly awaitJoin?: Effect$1.Effect<void, Error, Requirements> | undefined;
+  readonly start?: (() => Effect$1.Effect<void, Error, Requirements>) | undefined;
+  readonly drain: (policy: CommandDrainPolicy) => Effect$1.Effect<ReadonlyArray<RunInputCommand>, Error, Requirements>;
+  readonly end?: (() => Effect$1.Effect<void, never, Requirements>) | undefined;
 }
 /** Decision returned by an ephemeral approval adapter. */
 type RunApprovalDecision = {
@@ -146,7 +150,7 @@ interface RunApprovalRequest {
 }
 /** Dependency-neutral approval decision hook. */
 interface RunApprovalHook<Error = never, Requirements = never> {
-  readonly request: (request: RunApprovalRequest) => Effect.Effect<RunApprovalDecision, Error, Requirements>;
+  readonly request: (request: RunApprovalRequest) => Effect$1.Effect<RunApprovalDecision, Error, Requirements>;
 }
 /** Input passed to ordered context transformation and compaction adapters. */
 interface RunContextRequest {
@@ -187,7 +191,7 @@ interface RunContextRequest {
  * Layer once per Turn and keeps it through compaction, dispatch, accounting, and overflow retry.
  */
 interface ResolvedModelCall {
-  readonly model: Layer.Layer<LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName>;
+  readonly model: Layer$1.Layer<LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName>;
   readonly context: ModelCallContext;
   /**
    * The selected provider's native Tool schema transformer, such as toCodecOpenAI or
@@ -234,7 +238,7 @@ interface RunContextHook<Error = never, Requirements = never> {
    * the next Turn starts. Acquire resources shared across Turns in a surrounding
    * Run Layer or Scope instead.
    */
-  readonly prepare: (request: RunContextRequest) => Effect.Effect<PreparedRunContext, Error, Requirements>;
+  readonly prepare: (request: RunContextRequest) => Effect$1.Effect<PreparedRunContext, Error, Requirements>;
 }
 /**
  * Supplies model-visible reference context for one Turn without changing the
@@ -247,7 +251,7 @@ interface RunContextHook<Error = never, Requirements = never> {
  * empty Prompt when the Turn needs no references.
  */
 interface RunTransientContextHook<Error = never, Requirements = never> {
-  readonly load: (request: RunContextRequest) => Effect.Effect<Prompt.RawInput, Error, Requirements>;
+  readonly load: (request: RunContextRequest) => Effect$1.Effect<Prompt.RawInput, Error, Requirements>;
 }
 /** Context service failures retain their concrete tags and structured fields. */
 type RunContextPreparationError = AgentInputError | MemoryRecallError | CompactionError;
@@ -299,7 +303,7 @@ interface RunCostEstimateRequest {
  * Host-owned price lookup; durable hosts close every dependency before installing it. Raw usage
  * remains the first argument for source and runtime compatibility with the original estimator API.
  */
-type RunCostEstimator<Error = never, Requirements = never> = (usage: Response.Usage, request: RunCostEstimateRequest) => Effect.Effect<RunCostEstimateValue, Error, Requirements>;
+type RunCostEstimator<Error = never, Requirements = never> = (usage: Response.Usage, request: RunCostEstimateRequest) => Effect$1.Effect<RunCostEstimateValue, Error, Requirements>;
 /**
  * Dependency-neutral hierarchical budget hook. A typed failure at a Turn-seam
  * consumption or a stream-guard pull stops the Run. A mid-pass programmatic
@@ -313,8 +317,8 @@ interface RunBudgetHook<Error = never, Requirements = never> {
    * Guard one active model or Tool stream pull. Hierarchical budget adapters
    * use an absolute deadline so repeated pulls share one duration allowance.
    */
-  readonly guard: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | Error, R | Requirements>;
-  readonly consume: (delta: RunUsageDelta) => Effect.Effect<void, Error, Requirements>;
+  readonly guard: <A, E, R>(effect: Effect$1.Effect<A, E, R>) => Effect$1.Effect<A, E | Error, R | Requirements>;
+  readonly consume: (delta: RunUsageDelta) => Effect$1.Effect<void, Error, Requirements>;
 }
 /**
  * One application Tool Call of a completed Turn as the durable runtime sees
@@ -365,9 +369,9 @@ interface RunToolAuthorizationRequest {
 }
 /** Host policy invoked before each executable native or programmatic application call. */
 interface RunToolAuthorizationHook<Error = never, Requirements = never> {
-  readonly authorize: (request: RunToolAuthorizationRequest) => Effect.Effect<RunToolAuthorizationDecision, Error, Requirements>;
+  readonly authorize: (request: RunToolAuthorizationRequest) => Effect$1.Effect<RunToolAuthorizationDecision, Error, Requirements>;
 }
-declare const RunContextPreparation_base: Context.ServiceClass<RunContextPreparation, "@effect-agent/engine/RunContextPreparation", {
+declare const RunContextPreparation_base: Context$1.ServiceClass<RunContextPreparation, "@effect-agent/engine/RunContextPreparation", {
   /** Optional transformation of the model-visible prompt. */
   readonly hook?: RunContextHook<RunContextPreparationError, never> | undefined;
   /** Optional per-Turn reference context, excluded from history and compaction coverage. */
@@ -384,8 +388,8 @@ declare const RunContextPreparation_base: Context.ServiceClass<RunContextPrepara
  */
 declare class RunContextPreparation extends RunContextPreparation_base {}
 /** Explicit no-preparer Layer used by compatible runtime assemblies. */
-declare const RunContextPreparationPassthrough: Layer.Layer<RunContextPreparation>;
-declare const RunToolAuthorization_base: Context.ServiceClass<RunToolAuthorization, "@effect-agent/engine/RunToolAuthorization", RunToolAuthorizationHook<AgentToolAuthorizationCheckError, never>>;
+declare const RunContextPreparationPassthrough: Layer$1.Layer<RunContextPreparation>;
+declare const RunToolAuthorization_base: Context$1.ServiceClass<RunToolAuthorization, "@effect-agent/engine/RunToolAuthorization", RunToolAuthorizationHook<AgentToolAuthorizationCheckError, never>>;
 /**
  * Host action-time authority for native and programmatic application Tools. Implementations close over
  * their dependencies at Layer construction and return a denial when execution is not authorized.
@@ -397,7 +401,7 @@ declare const RunToolAuthorization_base: Context.ServiceClass<RunToolAuthorizati
  */
 declare class RunToolAuthorization extends RunToolAuthorization_base {
   /** Explicit compatibility policy: Tool execution requires no additional host authorization. */
-  static readonly allowAll: Layer.Layer<RunToolAuthorization>;
+  static readonly allowAll: Layer$1.Layer<RunToolAuthorization>;
 }
 /**
  * Payload of one durable response commit: the completed Turn's identity, its
@@ -439,8 +443,8 @@ interface RunTurnUsage {
   readonly turn: number;
   readonly usage: ModelCallUsage;
 }
-declare const ModelUsageAccounting_base: Context.ServiceClass<ModelUsageAccounting, "@effect-agent/engine/ModelUsageAccounting", {
-  readonly noteIncompleteUsage: (turn: number) => Effect.Effect<void>;
+declare const ModelUsageAccounting_base: Context$1.ServiceClass<ModelUsageAccounting, "@effect-agent/engine/ModelUsageAccounting", {
+  readonly noteIncompleteUsage: (turn: number) => Effect$1.Effect<void>;
 }>;
 /**
  * Attempt-local accounting for provider invocations without retained usage.
@@ -449,10 +453,10 @@ declare const ModelUsageAccounting_base: Context.ServiceClass<ModelUsageAccounti
  * explicitly supply the no-op implementation.
  */
 declare class ModelUsageAccounting extends ModelUsageAccounting_base {
-  static readonly layerEphemeral: Layer.Layer<ModelUsageAccounting, never, never>;
+  static readonly layerEphemeral: Layer$1.Layer<ModelUsageAccounting, never, never>;
 }
-declare const AgentUpdateAcceptance_base: Context.ServiceClass<AgentUpdateAcceptance, "@effect-agent/engine/AgentUpdateAcceptance", {
-  readonly accept: (update: Update) => Effect.Effect<Update, UpdateError>;
+declare const AgentUpdateAcceptance_base: Context$1.ServiceClass<AgentUpdateAcceptance, "@effect-agent/engine/AgentUpdateAcceptance", {
+  readonly accept: (update: Update) => Effect$1.Effect<Update, UpdateError>;
 }>;
 /**
  * Accepts an interpreter-validated update before semantic publication. Durable hosts bind this
@@ -461,7 +465,7 @@ declare const AgentUpdateAcceptance_base: Context.ServiceClass<AgentUpdateAccept
  * Ephemeral entry points explicitly accept only into their Run-local event stream.
  */
 declare class AgentUpdateAcceptance extends AgentUpdateAcceptance_base {
-  static readonly layerEphemeral: Layer.Layer<AgentUpdateAcceptance, never, never>;
+  static readonly layerEphemeral: Layer$1.Layer<AgentUpdateAcceptance, never, never>;
 }
 /**
  * Dependency-neutral durability seam implemented by a durable coordinator.
@@ -482,20 +486,20 @@ interface RunDurabilityHook<Error = never, Requirements = never> {
     readonly turn: number;
     readonly turnId: TurnId;
     readonly restart: number;
-  }) => Effect.Effect<void, Error, Requirements>) | undefined;
+  }) => Effect$1.Effect<void, Error, Requirements>) | undefined;
   /** Stage the exact request declarations for the existing canonical response append. */
-  readonly noteToolExposure?: ((turn: number, snapshot: Snapshot) => Effect.Effect<void, Error, Requirements>) | undefined;
+  readonly noteToolExposure?: ((turn: number, snapshot: Snapshot) => Effect$1.Effect<void, Error, Requirements>) | undefined;
   /**
    * Reserve cumulative programmatic calls and grace finalization before external execution.
    * Calls are serialized across the Run. A committed reservation
    * is never refunded, even if ownership is lost before the Handler or model starts.
    * Coordinators must append fenced, schema-backed records before returning.
    */
-  readonly reservePolicyUsage?: ((usage: Pick<RunPolicyUsage, "programmaticToolCalls" | "finalizationUsed">) => Effect.Effect<void, Error, Requirements>) | undefined;
+  readonly reservePolicyUsage?: ((usage: Pick<RunPolicyUsage, "programmaticToolCalls" | "finalizationUsed">) => Effect$1.Effect<void, Error, Requirements>) | undefined;
   /** After validated staged response events are emitted, before approval preflight. */
-  readonly commitResponse: (commit: RunTurnResponseCommit) => Effect.Effect<void, Error, Requirements>;
+  readonly commitResponse: (commit: RunTurnResponseCommit) => Effect$1.Effect<void, Error, Requirements>;
   /** After every approval and host authorization resolved allowed, before any handler starts. */
-  readonly prepareToolCalls: (calls: ReadonlyArray<RunToolCallDescriptor>) => Effect.Effect<void, Error, Requirements>;
+  readonly prepareToolCalls: (calls: ReadonlyArray<RunToolCallDescriptor>) => Effect$1.Effect<void, Error, Requirements>;
   readonly step: RunStepHook<Error, Requirements>;
   /**
    * RUN-026: called at the pre-Turn seam BEFORE the engine applies a
@@ -506,7 +510,7 @@ interface RunDurabilityHook<Error = never, Requirements = never> {
    * that recovery cannot reproduce. Reject unpersistable decisions in the typed
    * error channel; success means the same replacement and coverage are durable.
    */
-  readonly commitCompaction: (commit: RunCompactionCommit) => Effect.Effect<void, Error, Requirements>;
+  readonly commitCompaction: (commit: RunCompactionCommit) => Effect$1.Effect<void, Error, Requirements>;
   /**
    * RUN-023: stage one completed model call's usage for the Turn's canonical
    * commit (the response record carries it for resume re-seeding). Staging is
@@ -515,7 +519,7 @@ interface RunDurabilityHook<Error = never, Requirements = never> {
    * usage a later Attempt needs, so ownership changes would silently reset
    * token budgets instead of failing closed.
    */
-  readonly noteTurnUsage: (usage: RunTurnUsage) => Effect.Effect<void, Error, Requirements>;
+  readonly noteTurnUsage: (usage: RunTurnUsage) => Effect$1.Effect<void, Error, Requirements>;
 }
 /**
  * `DefinitionDigests`-shaped digests of one child Agent Binding in plain
@@ -636,8 +640,8 @@ interface RunSubagentJoinRequest {
  * — absence means no durable claim is being made.
  */
 interface RunSubagentHook<Error = never, Requirements = never> {
-  readonly establish: (request: RunSubagentEstablishRequest) => Effect.Effect<ChildEstablishStatus, Error, Requirements>;
-  readonly join: (request: RunSubagentJoinRequest) => Effect.Effect<void, Error, Requirements>;
+  readonly establish: (request: RunSubagentEstablishRequest) => Effect$1.Effect<ChildEstablishStatus, Error, Requirements>;
+  readonly join: (request: RunSubagentJoinRequest) => Effect$1.Effect<void, Error, Requirements>;
 }
 /** One declared Tool Call of a Turn being resumed, in canonical encoded form. */
 interface RunTurnResumeCall {
@@ -655,13 +659,13 @@ interface RunTurnResumeCall {
  * enter official history. The result remains the exact canonical JSON value
  * carried by the Tool message.
  */
-declare const RunTurnResumeSettledCallSchema: Schema.Struct<{
-  readonly toolSelection: Schema.optionalKey<typeof Selection>;
-  readonly id: Schema.NonEmptyString;
-  readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-  readonly isFailure: Schema.Boolean;
+declare const RunTurnResumeSettledCallSchema: Schema$1.Struct<{
+  readonly toolSelection: Schema$1.optionalKey<typeof Selection>;
+  readonly id: Schema$1.NonEmptyString;
+  readonly result: Schema$1.Codec<Schema$1.Json, Schema$1.Json, never, never>;
+  readonly isFailure: Schema$1.Boolean;
   /** Engine-owned rejection evidence; never inferred from the encoded result. */
-  readonly budgetRejected: Schema.optionalKey<Schema.Literal<true>>;
+  readonly budgetRejected: Schema$1.optionalKey<Schema$1.Literal<true>>;
 }>;
 type RunTurnResumeSettledCall = typeof RunTurnResumeSettledCallSchema.Type;
 /**
@@ -674,25 +678,25 @@ type RunTurnResumeSettledCall = typeof RunTurnResumeSettledCallSchema.Type;
  * call cannot exceed its cumulative total. Every committed Turn has a model
  * call, and a failure streak cannot exceed the declared Tool call count.
  */
-declare const RunResumeUsageSchema: Schema.Struct<{
-  readonly committedTurns: Schema.Natural;
-  readonly toolCalls: Schema.Natural;
-  readonly programmaticToolCalls: Schema.Natural;
-  readonly consecutiveToolFailures: Schema.Natural;
-  readonly finalizationUsed: Schema.Boolean;
-  readonly modelRestarts: Schema.optionalKey<Schema.Int>;
-  readonly modelCalls: Schema.Natural;
-  readonly webSearchCalls: Schema.optionalKey<Schema.Natural>;
-  readonly inputTokens: Schema.Natural;
-  readonly outputTokens: Schema.Natural;
-  readonly lastInputTokens: Schema.Natural;
-  readonly lastOutputTokens: Schema.Natural;
-  readonly costMicrousd: Schema.Natural;
-  readonly usageStatus: Schema.optionalKey<Schema.Literals<readonly ["complete", "partial", "unknown"]>>;
-  readonly pricingStatus: Schema.optionalKey<Schema.Literals<readonly ["complete", "partial", "unknown"]>>;
-  readonly unobservedModelCalls: Schema.optionalKey<Schema.Natural>;
+declare const RunResumeUsageSchema: Schema$1.Struct<{
+  readonly committedTurns: Schema$1.Natural;
+  readonly toolCalls: Schema$1.Natural;
+  readonly programmaticToolCalls: Schema$1.Natural;
+  readonly consecutiveToolFailures: Schema$1.Natural;
+  readonly finalizationUsed: Schema$1.Boolean;
+  readonly modelRestarts: Schema$1.optionalKey<Schema$1.Int>;
+  readonly modelCalls: Schema$1.Natural;
+  readonly webSearchCalls: Schema$1.optionalKey<Schema$1.Natural>;
+  readonly inputTokens: Schema$1.Natural;
+  readonly outputTokens: Schema$1.Natural;
+  readonly lastInputTokens: Schema$1.Natural;
+  readonly lastOutputTokens: Schema$1.Natural;
+  readonly costMicrousd: Schema$1.Natural;
+  readonly usageStatus: Schema$1.optionalKey<Schema$1.Literals<readonly ["complete", "partial", "unknown"]>>;
+  readonly pricingStatus: Schema$1.optionalKey<Schema$1.Literals<readonly ["complete", "partial", "unknown"]>>;
+  readonly unobservedModelCalls: Schema$1.optionalKey<Schema$1.Natural>;
   /** Verified direct-child reports, deduplicated by Run ID across Attempts. */
-  readonly children: Schema.optionalKey<Schema.$Array<typeof ChildRunUsage>>;
+  readonly children: Schema$1.optionalKey<Schema$1.$Array<typeof ChildRunUsage>>;
 }>;
 type RunResumeUsage = typeof RunResumeUsageSchema.Type;
 /**
@@ -739,11 +743,11 @@ interface RunTurnResume {
   readonly responseMessages?: Prompt.Prompt | undefined;
 }
 /** Run-level scheduler override; it may only make the Agent's finite bound stricter. */
-declare const RunSchedulingOverride: Schema.Union<readonly [Schema.Struct<{
-  readonly mode: Schema.Literal<"bounded">;
-  readonly concurrency: Schema.Int;
-}>, Schema.Struct<{
-  readonly mode: Schema.Literal<"sequential">;
+declare const RunSchedulingOverride: Schema$1.Union<readonly [Schema$1.Struct<{
+  readonly mode: Schema$1.Literal<"bounded">;
+  readonly concurrency: Schema$1.Int;
+}>, Schema$1.Struct<{
+  readonly mode: Schema$1.Literal<"sequential">;
 }>]>;
 type RunSchedulingOverride = typeof RunSchedulingOverride.Type;
 /** Dependency-neutral scheduling policy surrounding native Effect AI Tool handlers. */
@@ -757,7 +761,7 @@ interface RunSchedulingHook {
  * forms a barrier around neighboring parallel batches, including on recovery.
  * Ephemeral Runs may override this reference with `RunOptions.scheduling`.
  */
-declare const RunToolScheduling: Context.Reference<RunSchedulingHook>;
+declare const RunToolScheduling: Context$1.Reference<RunSchedulingHook>;
 /**
  * Tightening-only memory limits for one Run. The engine supplies finite ceilings for every field;
  * callers may lower them for a deployment or test but cannot widen the engine defaults.
@@ -798,7 +802,7 @@ interface RunOptions<HookError = never, HookRequirements = never> {
    * still require that Schema. The original value remains the policy input, and a saved prompt
    * is restored through `context` instead of rerendering the application's input prompt.
    */
-  readonly retainedInput?: Schema.Json | undefined;
+  readonly retainedInput?: Schema$1.Json | undefined;
   /** Initial or canonically restored run-scoped native selection. */
   readonly toolSelection?: Selection | undefined;
   /**
@@ -808,7 +812,7 @@ interface RunOptions<HookError = never, HookRequirements = never> {
    * reset the Run deadline or change prompt protection, and is not automatically inherited by spawned children.
    * Resources acquired here close with the current Turn, before the next Turn starts.
    */
-  readonly beforeTurn?: (() => Effect.Effect<void, HookError, HookRequirements>) | undefined;
+  readonly beforeTurn?: (() => Effect$1.Effect<void, HookError, HookRequirements>) | undefined;
   /** Reuse a Thread identity, including retained history, instead of allocating one. */
   readonly threadId?: ThreadId | undefined;
   /**
@@ -951,10 +955,10 @@ interface RunOptions<HookError = never, HookRequirements = never> {
    * PersistentHistory's on-success adapter rejects this hook;
    * the durable coordinator uses it for live Prompt state while its journal owns durable commits.
    */
-  readonly onHistory?: ((history: Prompt.Prompt) => Effect.Effect<void, HookError, HookRequirements>) | undefined;
+  readonly onHistory?: ((history: Prompt.Prompt) => Effect$1.Effect<void, HookError, HookRequirements>) | undefined;
 }
 type RunOptionsError<Options> = Options extends RunOptions<infer Error, infer _Requirements> ? Error : never;
 type RunOptionsRequirements<Options> = Options extends RunOptions<infer _Error, infer Requirements> ? Requirements : never;
 //#endregion
 export { RunTurnResponseCommit as $, RunInputCommand as A, RunSubagentChildIdentity as B, RunContextPreparationPassthrough as C, RunCostEstimateValue as D, RunCostEstimateRequest as E, RunOptions_d_exports as F, RunToolAuthorization as G, RunSubagentEstablishRequest as H, RunResumeUsage as I, RunToolAuthorizationRequest as J, RunToolAuthorizationDecision as K, RunResumeUsageSchema as L, RunOptions as M, RunOptionsError as N, RunCostEstimator as O, RunOptionsRequirements as P, RunTransientContextHook as Q, RunSchedulingHook as R, RunContextPreparationError as S, RunCostEstimate as T, RunSubagentHook as U, RunSubagentDigests as V, RunSubagentJoinRequest as W, RunToolFailureObserver as X, RunToolCallDescriptor as Y, RunToolScheduling as Z, RunBudgetHook as _, ChildEstablishWaiting as a, RunUsageDelta as at, RunContextHook as b, ModelToolFailure as c, ProgrammaticPreflightFailure as d, RunTurnResume as et, ProgrammaticToolFailure as f, RunApprovalRequest as g, RunApprovalHook as h, ChildEstablishStatus as i, RunTurnUsage as it, RunInputHook as j, RunDurabilityHook as k, ModelUsageAccounting as l, RunApprovalDecision as m, ChildEstablishDenied as n, RunTurnResumeSettledCall as nt, CommandDrainPolicy as o, ToolFailureObservation as ot, ResolvedModelCall as p, RunToolAuthorizationHook as q, ChildEstablishSettled as r, RunTurnResumeSettledCallSchema as rt, CurrentToolFailureObserver as s, toolFailureObserverLayer as st, AgentUpdateAcceptance as t, RunTurnResumeCall as tt, PreparedRunContext as u, RunBufferLimits as v, RunContextRequest as w, RunContextPreparation as x, RunCompactionCommit as y, RunSchedulingOverride as z };
-//# sourceMappingURL=RunOptions-BHmBa05n.d.mts.map
+//# sourceMappingURL=RunOptions-CkSZSuIh.d.mts.map

package/dist/{RunPolicyUsage-CUudVtg_.d.mts → RunPolicyUsage-QmYVw9z8.d.mts}

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 declare namespace RunPolicyUsage_d_exports {
   export { RunPolicyUsage };
 }
@@ -20,4 +20,4 @@ declare const RunPolicyUsage: Schema.Struct<{
 type RunPolicyUsage = typeof RunPolicyUsage.Type;
 //#endregion
 export { RunPolicyUsage_d_exports as n, RunPolicyUsage as t };
-//# sourceMappingURL=RunPolicyUsage-CUudVtg_.d.mts.map
+//# sourceMappingURL=RunPolicyUsage-QmYVw9z8.d.mts.map

package/dist/{Schedule-Bi_XVKLF.d.mts → Schedule-rEIiYnRq.d.mts}

@@ -1,6 +1,6 @@
-import { a as Receipt } from "./Receipt-BAHyigAF.mjs";
-import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-CaAkzGHL.mjs";
-import { _ as Digest, h as DefinitionDigests } from "./Records-Bm4Qt70a.mjs";
+import { a as Receipt } from "./Receipt-BkM21Qiu.mjs";
+import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-DvHruCSJ.mjs";
+import { _ as Digest, h as DefinitionDigests } from "./Records-CAQktL0z.mjs";
 import { Context, Effect, Schema } from "effect";
 declare namespace Schedule_d_exports {
   export { ScheduleAuthorizationDecision, ScheduleAuthorizationError, ScheduleAuthorizer, ScheduleCapacityError, ScheduleChange, ScheduleConfiguration, ScheduleConflict, ScheduleDestination, ScheduleDueCursor, ScheduleFailpoint, ScheduleFailpointError, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleManagementAuthorization, ScheduleManagementOperation, ScheduleNotFound, ScheduleOccurrenceAuthorization, ScheduleOwner, SchedulePage, SchedulePageRequest, SchedulePending, ScheduleRecord, ScheduleRefusal, ScheduleRetry, ScheduleRetryReason, ScheduleScope, ScheduleSkippedRange, ScheduleSnapshot, ScheduleSnapshotPage, ScheduleStorageError, ScheduleStore, ScheduleStoreFailure, ScheduleTiming, ScheduleTimingRequest, ScheduleValidationError, ScheduleWake, ScheduledEnvelope, ScheduledInputAdmission, ScheduledInputFailure, ScheduledInputRefused, ScheduledInputRetryable, SchedulingLimits, defaultSchedulingLimits };
@@ -844,4 +844,4 @@ declare const ScheduleFailpoint: Context.Reference<{
 }>;
 //#endregion
 export { ScheduleSnapshotPage as A, ScheduledInputAdmission as B, ScheduleRecord as C, ScheduleScope as D, ScheduleRetryReason as E, ScheduleTimingRequest as F, defaultSchedulingLimits as G, ScheduledInputRefused as H, ScheduleValidationError as I, ScheduleWake as L, ScheduleStore as M, ScheduleStoreFailure as N, ScheduleSkippedRange as O, ScheduleTiming as P, Schedule_d_exports as R, SchedulePending as S, ScheduleRetry as T, ScheduledInputRetryable as U, ScheduledInputFailure as V, SchedulingLimits as W, ScheduleNotFound as _, ScheduleChange as a, SchedulePage as b, ScheduleDestination as c, ScheduleFailpointError as d, ScheduleId as f, ScheduleManagementOperation as g, ScheduleManagementAuthorization as h, ScheduleCapacityError as i, ScheduleStorageError as j, ScheduleSnapshot as k, ScheduleDueCursor as l, ScheduleKey as m, ScheduleAuthorizationError as n, ScheduleConfiguration as o, ScheduleInstant as p, ScheduleAuthorizer as r, ScheduleConflict as s, ScheduleAuthorizationDecision as t, ScheduleFailpoint as u, ScheduleOccurrenceAuthorization as v, ScheduleRefusal as w, SchedulePageRequest as x, ScheduleOwner as y, ScheduledEnvelope as z };
-//# sourceMappingURL=Schedule-Bi_XVKLF.d.mts.map
+//# sourceMappingURL=Schedule-rEIiYnRq.d.mts.map

package/dist/{Subagent-Cxvuaius.mjs → Subagent-C-fyHbcp.mjs}

@@ -3,18 +3,18 @@ import { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from
 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 { i as Failure, o as Value } from "./FailureDiagnostic-D9oW23Cn.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 { 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-DZjdMjZn.mjs";
 import { BackgroundReporting, SubagentHost, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
-import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-Q50HloUc.mjs";
+import { a as SubagentDurability, i as AgentSpawner, o as SubagentDurabilityError, s as ToolCallWaiting } from "./AgentRuntime-BTfPyMXN.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";
+import { Tool, Toolkit } from "effect/unstable/ai";
 //#region src/capabilities/internal/subagent-contract.ts
 const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
 const Natural = Schema.Natural;
@@ -1496,4 +1496,4 @@ function background(targetOrDeclaration, selected) {
 //#endregion
 export { SubagentPolicy as _, layer as a, delegationAllocationFromPolicy as b, WorkerObservation as c, followUp as d, inspect as f, stop as g, start as h, background as i, awaitWorker as l, observe as m, SubagentResult as n, make as o, list as p, Subagent_exports as r, Worker as s, SubagentDurableAccounting as t, cancel as u, SubagentPrestartDenied as v, delegationCapsFromPolicy as x, SubagentProjectionFailure as y };
 
-//# sourceMappingURL=Subagent-Cxvuaius.mjs.map
+//# sourceMappingURL=Subagent-C-fyHbcp.mjs.map