@yielded/agent 0.1.0-beta.173 → 0.1.0-beta.175

package/dist/{Admin-BX9ns28E.d.mts → Admin-Qa3I1oA5.d.mts}

@@ -5,20 +5,20 @@ import { r as Update } from "./AgentUpdates-DksV4D0A.mjs";
 import { c as Selection, l as Snapshot } from "./ToolExposure-jTheYXrK.mjs";
 import { l as RunUsageSummary, r as ModelCallUsage } from "./Usage-CzZJ6A2n.mjs";
 import { a as ExhaustedLimit } from "./RunEvent-C5jVQZ6K.mjs";
-import { t as ThreadHistory } from "./ThreadHistory-ByxS8HU1.mjs";
+import { t as ThreadHistory } from "./ThreadHistory-KPPBJLJb.mjs";
 import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-DvHruCSJ.mjs";
 import { o as AgentInputError } from "./AgentError-CBH7_MjG.mjs";
 import { t as ToolParameterRejection } from "./ToolResult-5SdG8FE2.mjs";
 import { t as AgentPolicy } from "./AgentPolicy-B4lbCU2T.mjs";
-import { E as RunDispositionDeclaration, _ as InstructionSource, c as Definition, m as InputPromptSource, n as Any, r as AnyDefinition, t as Agent_d_exports, y as ModelServices } from "./Agent-9aBoIi74.mjs";
+import { E as RunDispositionDeclaration, _ as InstructionSource, c as Definition, m as InputPromptSource, n as Any, r as AnyDefinition, t as Agent_d_exports, y as ModelServices } from "./Agent-B39jRnFv.mjs";
 import { t as RunPolicyUsage } from "./RunPolicyUsage-QmYVw9z8.mjs";
 import { c as WorkerError, f as WorkerRef, n as AssignmentTerminal } from "./Worker-CHRaIsWu.mjs";
-import { G as RunToolAuthorization, O as RunCostEstimator, h as RunApprovalHook, ot as RunTurnToolResult, x as RunContextPreparation } from "./RunOptions-D8zxFIrZ.mjs";
+import { G as RunToolAuthorization, O as RunCostEstimator, h as RunApprovalHook, ot as RunTurnToolResult, x as RunContextPreparation } from "./RunOptions-Be77lKVZ.mjs";
 import { o as MessagingError, r as InputMessage } from "./Messaging-DF_IWnxV.mjs";
-import { t as MessagingHost } from "./MessagingHost-B8oKM7AC.mjs";
-import "./Messaging-C_6OOg_s.mjs";
-import { d as WorkerReportPreparationFailure, f as WorkerReporting, o as SubagentHost } from "./SubagentHost-B6w2m-SI.mjs";
-import { p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements } from "./AgentRuntime-BfP14534.mjs";
+import { t as MessagingHost } from "./MessagingHost-C6SOAcoG.mjs";
+import "./Messaging-SVu6rWV8.mjs";
+import { d as WorkerReportPreparationFailure, f as WorkerReporting, o as SubagentHost } from "./SubagentHost-D1xBgn9g.mjs";
+import { p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements } from "./AgentRuntime-CHDyRbSf.mjs";
 import { $ as RecordEnvelope, Ct as ToolApprovalDecided, Dt as ToolCallSettled, H as ModelResponseRecorded, It as WorkerInputCompleted, K as PersistedJson, Mt as UserInputRecorded, Pt as WorkerAdmission, Rt as WorkerInputRequested, W as PROMPT_EVIDENCE_TAGS, Wt as WorkerStopRequested, Y as PromptRecordEnvelope, _t as SubagentRequested, a as BatchId, b as DefinitionDigests, bt as SubmissionSettledRecord, d as CanonicalRecordEnvelope, et as RecordId, ft as RunStartedRecord, ht as SubagentJoined, i as ApprovalDecision, l as CanonicalBatch, m as CompactionCreated, p as CanonicalSequence, pt as SettlementFailureDiagnostic, q as ProducerId, r as AgentUpdateEmitted, st as RunContinuation, t as AbortRequested, tt as RecordJson, v as DeclaredToolCall, vt as SubagentStarted, wt as ToolApprovalRequested, x as DeploymentId, y as DefinitionDigestInput, yt as SubmissionSettled } from "./Records-BTnGRdcf.mjs";
 import { t as DigestError } from "./Digest-DjUgS5PG.mjs";
 import { n as DurableRuntimeFailpoint, r as DurableRuntimeFailpointError } from "./DurableFailpoint-BugHZKvJ.mjs";
@@ -146,7 +146,7 @@ type EntryWorkerRequirements<Entry> = Entry extends {
 }> : never;
 type AttemptLayerRequirements<Requirements, AttemptLayer> = AttemptLayer extends ((context: AgentAttemptContext) => Layer.Layer<infer Provides, never, infer Requires>) ? Exclude<Requirements, Provides> | Requires : Requirements;
 type EntryRequirements<Entry> = Entry extends unknown ? AttemptLayerRequirements<EntryWorkerRequirements<Entry>, "attemptLayer" extends keyof Entry ? Entry["attemptLayer"] : undefined> : never;
-type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = [Entries[number]] extends [never] ? never : EntryRequirements<Entries[number]>;
+type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = EntryRequirements<Entries[number]>;
 /** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */
 declare const compileRegistrations: <const Entries extends ReadonlyArray<AgentRegistration>>(entries: Entries) => Effect.Effect<ReadonlyArray<ResolvedBinding>, DigestError, Crypto.Crypto | RegistrationRequirements<Entries>>;
 declare namespace AgentRegistration_d_exports {
@@ -178,7 +178,7 @@ interface JournalMetadata {
   }>;
 }
 declare namespace RunJournal_d_exports {
-  export { JournalBoundary, RunJournalContext, RunJournalError, RunJournalProjection, RunJournalUsage, TurnCommitInput, agentUpdateRecordId, approvalDecisionBatchId, childIdempotencyKeyFor, childThreadIdFor, compactionBatchId, compactionRecordId, firstWorkerInputRecordId, markUnknownBatchId, modelResponseInterruptedBatchId, modelResponseInterruptedRecordId, modelResponseRecordId, peerMessageRecordId, projectRunJournal, projectRunJournalStream, promptFromCanonicalRecords, runCompletedRecordId, runDurationBatchId, runDurationRecordId, runIdForSubmission, runStartedBatchId, runStartedRecordId, subagentJoinBatchId, subagentJoinedRecordId, subagentLineageBatchId, subagentLineageRecordId, subagentRequestedBatchId, subagentRequestedRecordId, subagentStartedBatchId, subagentStartedRecordId, toolApprovalDecisionRecordId, toolApprovalRequestRecordId, toolCallResolutionBatchId, toolCallResolvedRecordId, toolCallResultBatchId, toolCallSettledRecordId, toolCallUnknownRecordId, toolStepSettledBatchId, toolStepSettledRecordId, turnApprovalsBatchId, turnBatchId, turnCanonicalBatch, turnIdForRun, turnResponseBatch, turnResponseBatchId, turnResultsBatch, turnResultsBatchId, workerInputRecordId, workerOriginRecordId, workerReportRecordId };
+  export { JournalBoundary, RunJournalContext, RunJournalError, RunJournalProjection, RunJournalUsage, TurnCommitInput, agentUpdateRecordId, approvalDecisionBatchId, childIdempotencyKeyFor, childThreadIdFor, compactionBatchId, compactionRecordId, firstWorkerInputRecordId, initialRunJournal, markUnknownBatchId, modelResponseInterruptedBatchId, modelResponseInterruptedRecordId, modelResponseRecordId, peerMessageRecordId, projectRunJournal, projectRunJournalStream, promptFromCanonicalRecords, runCompletedRecordId, runDurationBatchId, runDurationRecordId, runIdForSubmission, runStartedBatchId, runStartedRecordId, subagentJoinBatchId, subagentJoinedRecordId, subagentLineageBatchId, subagentLineageRecordId, subagentRequestedBatchId, subagentRequestedRecordId, subagentStartedBatchId, subagentStartedRecordId, toolApprovalDecisionRecordId, toolApprovalRequestRecordId, toolCallResolutionBatchId, toolCallResolvedRecordId, toolCallResultBatchId, toolCallSettledRecordId, toolCallUnknownRecordId, toolStepSettledBatchId, toolStepSettledRecordId, turnApprovalsBatchId, turnBatchId, turnCanonicalBatch, turnIdForRun, turnResponseBatch, turnResponseBatchId, turnResultsBatch, turnResultsBatchId, workerInputRecordId, workerOriginRecordId, workerReportRecordId };
 }
 declare const RunJournalError_base: Schema.Class<RunJournalError, Schema.TaggedStruct<"RunJournalError", {
   readonly message: Schema.String;
@@ -241,7 +241,7 @@ declare const workerOriginRecordId: (threadId: ThreadId) => RecordId;
 declare const workerReportRecordId: (messageId: IdempotencyKey) => RecordId;
 declare const peerMessageRecordId: (messageId: IdempotencyKey) => RecordId;
 /** Same immutable tuple used by native update admission; callers never parse its hash. */
-declare const agentUpdateRecordId: (threadId: string & Brand.Brand<"@effect-agent/core/ThreadId">, runId: string & Brand.Brand<"@effect-agent/core/RunId">, updateId: string & Brand.Brand<"@effect-agent/thread/IdempotencyKey">) => Effect.Effect<string & Brand.Brand<"@effect-agent/thread/RecordId">, DigestError, Crypto.Crypto>;
+declare const agentUpdateRecordId: (threadId: string & Brand.Brand<"@effect-agent/core/ThreadId">, runId: string & Brand.Brand<"@effect-agent/core/RunId">, updateId: string & Brand.Brand<"@effect-agent/thread/IdempotencyKey">) => Effect.Effect<string & Brand.Brand<"@effect-agent/thread/RecordId">, DigestError, import("effect/Crypto").Crypto>;
 /** Deterministic batch identity of one Turn's `ToolCallUnknown` marking append. */
 declare const markUnknownBatchId: (submissionId: SubmissionId, turn: number) => BatchId;
 /** Deterministic canonical record identity of one Tool Call's `ToolCallUnknown` record. */
@@ -373,6 +373,9 @@ interface RunJournalProjection {
   /** Last successful singleton Tool awaiting possible context-control interpretation by the engine. */
   readonly pendingContextToolCallId?: string | undefined;
 }
+/** Internal first-Run projection after exact input/checkpoint-absence verification. The
+ * new UserInputRecorded contributes no model message; the engine evaluates it later. */
+declare const initialRunJournal: (history: Prompt.Prompt) => RunJournalProjection;
 /**
  * Pure projection: rebuild one Run's resume state from canonical records (DUR-015). Canonical
  * order is authoritative; the fold projects each `ModelResponseRecorded` Turn and the
@@ -431,6 +434,7 @@ declare const projectRunJournal: (records: ReadonlyArray<CanonicalRecordEnvelope
  * Prompt (plan §Coordinator flow step 3).
  */
 declare const promptFromCanonicalRecords: (records: ReadonlyArray<CanonicalRecordEnvelope>) => Effect.Effect<Prompt.Prompt, RunJournalError>;
+/** Everything one committed Turn contributes to its canonical batch. */
 interface TurnCommitInput {
   readonly toolResultMaxBytes?: number | undefined;
   readonly toolSelectionMaxBytes?: number | undefined;
@@ -479,7 +483,7 @@ interface TurnCommitInput {
  * joins the response in the same atomic batch. Other application Turns split into
  * `turnResponseBatch` + `turnResultsBatch` before execution.
  */
-declare const turnCanonicalBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, DigestError | RunJournalError, Crypto.Crypto>;
+declare const turnCanonicalBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, RunJournalError, never>;
 /**
  * Commit the normalized response and original operation contracts before application Tools
  * execute, or promote a deferred readonly response before a persisted call-scoped capability.
@@ -487,14 +491,14 @@ declare const turnCanonicalBatch: (input: TurnCommitInput) => Effect.Effect<Cano
  * loss; approvals and the dispatch fence remain separate execution requirements. Provider
  * results stay in assistant content. Application outcomes belong to the results commit.
  */
-declare const turnResponseBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, DigestError | RunJournalError, Crypto.Crypto>;
+declare const turnResponseBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, RunJournalError, never>;
 /**
  * Commit 5 of a tool-declaring Turn (plan §2.1): the Turn's `ToolCallSettled` records in
  * declaration order under batch identity `turn-results:{runId}:{turn}` — the batch becomes
  * model-visible atomically. A completion after already committed Tool results gets its own
  * terminal batch; it never rewrites or repeats the earlier Tool outcomes.
  */
-declare const turnResultsBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, DigestError | RunJournalError, Crypto.Crypto>;
+declare const turnResultsBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, RunJournalError, never>;
 //#endregion
 //#region src/durable/internal/StorageOwner.d.ts
 type MutationGate = <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
@@ -1615,7 +1619,7 @@ interface ThreadArchiveStorage {
   readonly verify: (request: ThreadArchiveRangeRequest) => Effect.Effect<ThreadArchiveRange, ReadFailure>;
 }
 declare namespace ThreadWork_d_exports {
-  export { CanonicalWorkEntry, MAX_RECOVERY_PAGES, MAX_RECOVERY_WORK_ITEMS, MAX_WORK_CURSOR_CHARS, MAX_WORK_ENTRY_BYTES, MAX_WORK_PAGE_BYTES, MAX_WORK_PAGE_ENTRIES, MAX_WORK_REBUILD_BYTES, MAX_WORK_REBUILD_RECORDS, ThreadWorkCursor, ThreadWorkDiscovery, ThreadWorkEntry, ThreadWorkPage, ThreadWorkRequest, ThreadWorkStorage, WORK_INDEX_VERSION, WorkDiscoveryUnavailable, WorkIndexChange, WorkIndexProgress, WorkIndexRebuildRequest, WorkOwner, WorkStateReference, WorkThreadsPage, WorkThreadsRequest, WorkerReportingMode, admissionWork, advanceWorkEntry, decodeWorkCursor, deliveryPredecessor, encodeWorkCursor, operationEvidence, resolveWorkEvidence, validateWorkPage, workId, workIndexChanges };
+  export { CanonicalWorkEntry, FreshAdmissionWork, MAX_RECOVERY_PAGES, MAX_RECOVERY_WORK_ITEMS, MAX_WORK_CURSOR_CHARS, MAX_WORK_ENTRY_BYTES, MAX_WORK_PAGE_BYTES, MAX_WORK_PAGE_ENTRIES, MAX_WORK_REBUILD_BYTES, MAX_WORK_REBUILD_RECORDS, ThreadWorkCursor, ThreadWorkDiscovery, ThreadWorkEntry, ThreadWorkPage, ThreadWorkRequest, ThreadWorkStorage, WORK_INDEX_VERSION, WorkDiscoveryUnavailable, WorkIndexChange, WorkIndexProgress, WorkIndexRebuildRequest, WorkOwner, WorkStateReference, WorkThreadsPage, WorkThreadsRequest, WorkerReportingMode, admissionWork, advanceWorkEntry, decodeWorkCursor, deliveryPredecessor, encodeWorkCursor, operationEvidence, resolveWorkEvidence, validateWorkPage, workId, workIndexChanges };
 }
 declare const WORK_INDEX_VERSION = 3;
 declare const MAX_WORK_PAGE_ENTRIES = 128;
@@ -1862,6 +1866,12 @@ declare const ThreadWorkCursor: Schema.Struct<{
   readonly after: Schema.optionalKey<Schema.NonEmptyString>;
 }>;
 type ThreadWorkCursor = typeof ThreadWorkCursor.Type;
+/** Local snapshot request; it grants no claim or dispatch authority. */
+declare const FreshAdmissionWork: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>;
+type FreshAdmissionWork = typeof FreshAdmissionWork.Type;
 declare const WorkThreadsRequest: Schema.Struct<{
   readonly afterThreadId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
   readonly limit: Schema.Int;
@@ -1897,6 +1907,9 @@ declare const WorkDiscoveryUnavailable_base: Schema.Class<WorkDiscoveryUnavailab
 declare class WorkDiscoveryUnavailable extends WorkDiscoveryUnavailable_base {}
 /** Native owner pages and canonical-index maintenance, implemented at the storage owner. */
 interface ThreadWorkStorage {
+  /** Native proof that this untouched root admission has no other recovery obligations.
+   * A caller must still claim and validate current controls before dispatch. */
+  readonly isOnlyFreshAdmission?: (request: FreshAdmissionWork) => Effect.Effect<boolean, ThreadStoreError>;
   readonly threads: (request: WorkThreadsRequest) => Effect.Effect<WorkThreadsPage, ThreadStoreError>;
   readonly page: (request: ThreadWorkRequest) => Effect.Effect<ThreadWorkPage, WorkDiscoveryUnavailable | ThreadStoreError>;
   /** One bounded pass. Append transactions and the completion check serialize with this pass. */
@@ -1923,7 +1936,7 @@ declare const decodeWorkCursor: (request: {
   readonly threadDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
   readonly source: "admissions" | "canonical" | "deliveries";
   readonly after?: string | undefined;
-}, ThreadStoreError, Crypto.Crypto>;
+}, ThreadStoreError, import("effect/Crypto").Crypto>;
 declare const encodeWorkCursor: (input: {
   readonly version: 3;
   readonly threadDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
@@ -2123,7 +2136,7 @@ type WorkIndexChange = {
  * these changes with the source batch. Rebuild folds the same rules in sequence order; it may
  * suppress a delivery handoff only after its authoritative delivery row exists.
  */
-declare const workIndexChanges: (envelope: CanonicalRecordEnvelope, reporting: WorkerReportingMode) => Effect.Effect<readonly WorkIndexChange[], ThreadStoreError, Crypto.Crypto>;
+declare const workIndexChanges: (envelope: CanonicalRecordEnvelope, reporting: WorkerReportingMode) => Effect.Effect<readonly WorkIndexChange[], ThreadStoreError, never>;
 /** Backfill is chronological. A state's creation identity never changes on later updates. */
 declare const advanceWorkEntry: (previous: CanonicalWorkEntry | undefined, next: CanonicalWorkEntry) => CanonicalWorkEntry;
 declare namespace ThreadStore_d_exports {
@@ -2301,6 +2314,8 @@ interface PreparedAppend extends AppendRequest {
     readonly json: string;
     /** Checkpoint wire from the same detached, validated execution capture. */
     readonly checkpointJson: string;
+    /** Schema-encoded fact array from this same capture, for the stable retry digest. */
+    readonly factsJson: string;
     readonly bytes: number;
   }>;
   readonly records: ReadonlyArray<{
@@ -2311,8 +2326,13 @@ interface PreparedAppend extends AppendRequest {
     readonly canonical: CanonicalBatch["records"][number];
   }>;
 }
+interface CapturedAppend extends PreparedAppend {
+  readonly records: ReadonlyArray<Omit<PreparedAppend["records"][number], "wire"> & {
+    readonly wire: typeof RecordEnvelope.Encoded;
+  }>;
+}
 declare const PreparedAppend: {
-  capture: (input: AppendRequest) => Effect.Effect<PreparedAppend, ThreadStoreError>;
+  capture: (input: AppendRequest) => Effect.Effect<CapturedAppend, ThreadStoreError>;
 };
 declare const AppendResult_base: Schema.Class<AppendResult, Schema.Struct<{
   readonly firstSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
@@ -3381,6 +3401,9 @@ interface RunWriter {
 }
 interface RunStorageSession extends RunWriter, RunOwnership {
   readonly claim: Claim;
+  /** Library-only initialization, before application/model IO. Hold progress before mutation
+   * so the captured controls and this owner's acknowledged input remain one read view. */
+  readonly withInitialization?: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | OwnershipLost, R>;
   readonly refresh: Effect.Effect<void, ThreadStoreFailure>;
   readonly publishSettlement: (batch: CanonicalBatch, executions?: ReadonlyArray<ExecutionUpdate>) => Effect.Effect<SettlementPublicationResult, SettlementPublicationFailure>;
 }
@@ -3575,6 +3598,11 @@ declare class RecoverySweepResult extends RecoverySweepResult_base {}
 /** Recover one bounded page of native work, optionally confined to one Thread. */
 interface RecoverySweepOptions {
   readonly threadId?: ThreadId;
+  /** Leave this incarnation's untouched root admissions to their first actual claim.
+   * A verified sole admission needs no recovery inventory; other owners retain bounded
+   * discovery and deferred reports. Neither case supplies ownership or a recovery decision:
+   * the Attempt still verifies current controls, journal, fencing and historyDigest. */
+  readonly deferUnclaimedAdmissions?: boolean;
   /** Continue the previous pass with the same Thread selection until its result has no cursor. */
   readonly cursor?: string;
 }
@@ -3876,7 +3904,7 @@ declare class DurableAgentRuntime extends DurableAgentRuntime_base {
    * Every claimed head must select exactly one current registered Definition. Worker calls
    * cannot replace these registrations or their captured services. Tool authorization is required.
    */
-  static layerRegistered<const Entries extends ReadonlyArray<AgentRegistration>>(registrations: Entries): Layer.Layer<DurableAgentRuntime, DigestError, Crypto.Crypto | DurableRuntimeConfig | DurableRuntimeFailpoint | RunStorage | RunToolAuthorization | StorageOwner | SubmissionLedger | ThreadStore | ToolReconciler | WakeScheduler | Exclude<[Entries[number]] extends [never] ? never : Entries[number] extends (infer T) ? T extends Entries[number] ? T extends unknown ? ("attemptLayer" extends keyof T ? T[keyof T & "attemptLayer"] : undefined) extends (infer T_1) ? T_1 extends ("attemptLayer" extends keyof T ? T[keyof T & "attemptLayer"] : undefined) ? T_1 extends ((context: AgentAttemptContext) => Layer.Layer<infer Provides, never, infer Requires>) ? Requires | Exclude<T extends {
+  static layerRegistered<const Entries extends ReadonlyArray<AgentRegistration>>(registrations: Entries): Layer.Layer<DurableAgentRuntime, DigestError, Crypto.Crypto | DurableRuntimeConfig | DurableRuntimeFailpoint | RunStorage | RunToolAuthorization | StorageOwner | SubmissionLedger | ThreadStore | ToolReconciler | WakeScheduler | Exclude<Entries[number] extends (infer T) ? T extends Entries[number] ? T extends unknown ? ("attemptLayer" extends keyof T ? T[keyof T & "attemptLayer"] : undefined) extends (infer T_1) ? T_1 extends ("attemptLayer" extends keyof T ? T[keyof T & "attemptLayer"] : undefined) ? T_1 extends ((context: AgentAttemptContext) => Layer.Layer<infer Provides, never, infer Requires>) ? Requires | Exclude<T extends {
     readonly agent: infer A extends ExecutableAgentBinding;
   } ? DurableWorkerRequirements<A> : T extends {
     readonly agent: infer D extends Definition<Schema.Top, Schema.Top, unknown, import("effect/ai/Toolkit").Any, RunDispositionDeclaration<never, Schema.Top> | undefined, unknown, Schema.Top | undefined> & {
@@ -4196,6 +4224,10 @@ declare const SubmissionSnapshot_base: Schema.Class<SubmissionSnapshot, Schema.S
   readonly inputPayload: Schema.declare<Schema.Json, Schema.Json>;
   readonly inputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
   readonly settledOutcome: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+  /** First committed finalization time; paired with settledRecordId by native adapters. */
+  readonly settledAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+  /** Exact canonical settlement behind the finalized projection; not a substitute for reading it. */
+  readonly settledRecordId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">>;
   readonly createdAt: Schema.DateTimeUtcFromString;
   readonly readyAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
   readonly admissionGroup: Schema.optionalKey<Schema.NonEmptyString>;
@@ -4983,7 +5015,9 @@ declare class LedgerError extends LedgerError_base {}
 type SubmissionLedgerFailure = AdmissionConflict | OwnershipLost | SettlementConflict | ApprovalConflict | UnknownResolutionConflict | JoinedToHost | ChildReservationConflict | LedgerError | AdmissionPolicyError;
 declare const SubmissionLedger_base: Context.ServiceClass<SubmissionLedger, "@effect-agent/thread/SubmissionLedger", {
   readonly capabilities: Effect.Effect<LedgerCapabilities>;
-  readonly admit: (request: AdmissionRequest) => Effect.Effect<AdmissionResult, AdmissionConflict | AdmissionPolicyError | LedgerError>;
+  readonly admit: (request: AdmissionRequest, options?: {
+    readonly readyIfInitialized?: boolean;
+  }) => Effect.Effect<AdmissionResult, AdmissionConflict | AdmissionPolicyError | LedgerError>;
   readonly markReady: (request: MarkReadyRequest) => Effect.Effect<void, LedgerError>;
   readonly lookup: (request: SubmissionLookup) => Effect.Effect<Option.Option<SubmissionSnapshot>, LedgerError>;
   /** Absent adapters fail closed when funding a worker from an explicitly selected input. */
@@ -5014,6 +5048,8 @@ declare const SubmissionLedger_base: Context.ServiceClass<SubmissionLedger, "@ef
   readonly beginChildBudgetRelease: (request: BeginChildBudgetReleaseRequest) => Effect.Effect<ChildBudgetReservationSnapshot, ChildReservationConflict | LedgerError>;
   readonly releaseChildBudget: (request: ReleaseChildBudgetRequest) => Effect.Effect<ChildBudgetReservationSnapshot, ChildReservationConflict | LedgerError>;
   readonly scanNonterminal: Stream.Stream<SubmissionWorkItem, LedgerError>;
+  /** Optional native snapshot for hosts that need the complete control worklist. */
+  readonly listNonterminal?: Effect.Effect<ReadonlyArray<SubmissionWorkItem>, LedgerError>;
   readonly loadRecoverySnapshot: (request: RecoverySnapshotRequest) => Effect.Effect<RecoverySnapshot, LedgerError>;
 }>;
 /**
@@ -5031,6 +5067,10 @@ declare const SubmissionLedger_base: Context.ServiceClass<SubmissionLedger, "@ef
  *   An optional `parentLinkage` is recorded immutably at first admission (SUB-016); a replay
  *   whose linkage diverges (present vs. absent, or different identities) fails with
  *   `AdmissionConflict` even when the input digest matches.
+ *   With `readyIfInitialized`, an adapter may insert a fresh ordinary Submission as ready
+ *   when it proves Thread initialization under the admission's owner transaction. Readiness,
+ *   its lifecycle fact and source progress commit with the receipt. Otherwise it returns
+ *   admitted and the caller completes materialization and `markReady` as usual.
  * - `resolveAdmission` — authoritative tri-state admission lookup by scoped idempotency key
  *   (SUB-031): `NotAdmitted` proves absence, `Admitted` carries the full snapshot, and
  *   `Indeterminate` states that the adapter cannot currently prove either. Only `NotAdmitted`
@@ -5770,5 +5810,5 @@ declare const RetryRefused_base: Schema.Class<RetryRefused, Schema.TaggedStruct<
  */
 declare class RetryRefused extends RetryRefused_base {}
 //#endregion
-export { ResumeFromTurnBoundary as $, ThreadArchiveRangeRequest as $a, ThreadWorkerCapacityRequest as $i, DurableAwaitFailure as $n, subagentRequestedBatchId as $o, ExecutionCheckpoint as $r, RecoverySnapshotRequest as $t, AwaitHostSettlement as A, WorkOwner as Aa, ThreadIdentityRequest as Ai, WaitingChild as An, childIdempotencyKeyFor as Ao, SubmissionStatus_d_exports as Ar, DurableBindingFailure as As, ChildReservationConflict as At, NoAction as B, operationEvidence as Ba, ThreadResolutionFact as Bi, submissionSettlementBatchId as Bn, projectRunJournal as Bo, SettlementPublication as Br, FundingOwnerRequest as Bt, renderRecoveryExplanation as C, ThreadWorkStorage as Ca, ThreadExportCursor as Ci, SuspensionReason as Cn, RunJournalError as Co, recoveryRepairBatchId as Cr, toolCallSettledRecordId as Cs, ApprovalDecisionIntent as Ct, AwaitApprovalDecision as D, WorkIndexChange as Da, ThreadExportSnapshot as Di, UnknownResolutionConflict as Dn, TurnCommitInput as Do, PendingSubmission as Dr, BindingSelection as Ds, ChildAttachmentSnapshot as Dt, ApplyUnknownResolutions as E, WorkDiscoveryUnavailable as Ea, ThreadExportRequest as Ei, UnknownResolutionCommand as En, RunJournal_d_exports as Eo, threadCreatedRecordId as Er, AgentRegistration as Es, BeginChildBudgetReleaseRequest as Et, DeclaredPendingBatchEvidence as F, admissionWork as Fa, ThreadPromptRead as Fi, settlementFailureFromRecord as Fn, markUnknownBatchId as Fo, RunStorageSession as Fr, compileBindingContracts as Fs, Claim as Ft, RecoveryDecision as G, MAX_ARCHIVE_RANGE_BYTES as Ga, ThreadStoreError as Gi, workerTerminalFromRecord as Gn, runDurationRecordId as Go, validateCanonicalSettlement as Gr, LedgerError as Gt, OpenToolCallEvidence as H, validateWorkPage as Ha, ThreadSelection as Hi, submissionSettlementRecordId as Hn, promptFromCanonicalRecords as Ho, SettlementPublicationFailure as Hr, JoinSnapshot as Ht, DelegationAdmissionEvidence as I, advanceWorkEntry as Ia, ThreadRead as Ii, submissionAbortBatchId as In, modelResponseInterruptedBatchId as Io, RunWriter as Ir, compileRegistrations as Is, ClaimHandoff as It, ReleaseOrphanChildReservation as J, MAX_CANONICAL_BATCH_BYTES as Ja, ThreadTail as Ji, DurableAgentRuntime as Jn, runStartedRecordId as Jo, AppendConflict as Jr, MarkReadyRequest as Jt, RecoveryEvidence as K, MAX_ARCHIVE_RANGE_PAGE as Ka, ThreadStoreFailure as Ki, ApprovalSuspensionError as Kn, runIdForSubmission as Ko, validateJoinedSettlement as Kr, MarkInputAppliedRequest as Kt, EnsureWaitingForChild as L, decodeWorkCursor as La, ThreadReadRequest as Li, submissionAbortRecordId as Ln, modelResponseInterruptedRecordId as Lo, layer as Lr, definitionDigestsEqual as Ls, ClaimJoiningRequest as Lt, AwaitUnknownResolution as M, WorkThreadsPage as Ma, ThreadNotMaterialized as Mi, WorkerLedgerState as Mn, compactionBatchId as Mo, RunChildBudgetReservation as Mr, ExecutableAgentBinding as Ms, ChildReservationStatus as Mt, CompleteChildAdmission as N, WorkThreadsRequest as Na, ThreadObservation as Ni, WorkerStopCommand as Nn, compactionRecordId as No, RunOwnership as Nr, ReplayVersions as Ns, ChildSettledNotification as Nt, AwaitChildAdmissionResolution as O, WorkIndexProgress as Oa, ThreadExportSource as Oi, UnknownResolutionIntent as On, agentUpdateRecordId as Oo, SettledSubmission as Or, BindingUnavailable as Os, ChildBudgetReservationRequest as Ot, CompleteMaterialization as P, WorkerReportingMode as Pa, ThreadPeerCountRequest as Pi, approvalDecisionsCover as Pn, firstWorkerInputRecordId as Po, RunStorage as Pr, ResolvedBinding as Ps, ChildSettledOutcome as Pt, RepairSubagentStartLink as Q, ThreadArchiveRangeRead as Qa, ThreadWorkerCapacity as Qi, DurableApprovalSuspension as Qn, subagentLineageRecordId as Qo, CommitBatch as Qr, RecoverySnapshot as Qt, FinalizeLedgerFromHistory as R, deliveryPredecessor as Ra, ThreadReader as Ri, submissionInputBatchId as Rn, modelResponseRecordId as Ro, make as Rr, ClaimRequest as Rt, recoveryDecisionMeaning as S, ThreadWorkRequest as Sa, ThreadExportBatch as Si, SuspensionOutcome as Sn, RunJournalContext as So, isolateRecovery as Sr, JournalRecordEnvelope as Ss, ApprovalDecisionCommand as St, ApplyJoinAccounting as T, WORK_INDEX_VERSION as Ta, ThreadExportRejected as Ti, UnknownResolution as Tn, RunJournalUsage as To, threadCreatedBatchId as Tr, AgentAttemptContext as Ts, AttachChildToReservationRequest as Tt, PendingApprovalEvidence as U, workId as Ua, ThreadStore as Ui, unknownResolutionKind as Un, runCompletedRecordId as Uo, SettlementPublicationResult as Ur, JoiningClaim as Ut, OpenDelegationCallEvidence as V, resolveWorkEvidence as Va, ThreadRunInputRequest as Vi, submissionSettlementId as Vn, projectRunJournalStream as Vo, SettlementPublicationAuthority as Vr, InputAppliedMarker as Vt, PropagateChildAbort as W, workIndexChanges as Wa, ThreadStoreDiagnostic as Wi, unknownResolutionMatchesResult as Wn, runDurationBatchId as Wo, SettlementPublisher as Wr, LedgerCapabilities as Wt, RepairJoinMarker as X, ThreadArchiveRangePage as Xa, ThreadVerificationRequest as Xi, DurableApprovalFailure as Xn, subagentJoinedRecordId as Xo, AppendResult as Xr, OwnershipLost as Xt, RepairInputMarker as Y, ThreadArchiveRange as Ya, ThreadTailRequest as Yi, DurableAgentRuntime_d_exports as Yn, subagentJoinBatchId as Yo, AppendRequest as Yr, MarkUnknownRequest as Yt, RepairReadiness as Z, ThreadArchiveRangePublish as Za, ThreadVerificationStorage as Zi, DurableApprovalResolver as Zn, subagentLineageBatchId as Zo, CheckpointRejected as Zr, ParentLinkage as Zt, RetryCommand as _, MAX_WORK_REBUILD_RECORDS as _a, ThreadApprovalFact as _i, SubmissionScheduling as _n, OwnerGeneration as _o, RecoverySweepOptions as _r, turnResultsBatch as _s, AdmissionPolicyError as _t, IntegrityCheck as a, makeTransferFactCheck as aa, MAX_THREAD_EXPORT_CURSOR_CHARS as ai, ResolutionSafeToRetry as an, LifecyclePublicationConfig as ao, DurableRetryFailure as ar, toolCallResolutionBatchId as as, SettleJoinedWithHost as at, obligationSeverityOf as b, ThreadWorkEntry as ba, ThreadCommands as bi, SubmissionWorkItem as bn, makeStorageOwner as bo, WorkRecoveryRequest as br, workerOriginRecordId as bs, AdmissionResult as bt, IntegrityReport as c, transferPageFits as ca, PreparedAppend as ci, SettlementConflict as cn, LifecyclePublicationHandler as co, DurableSubmitAgent as cr, toolCallUnknownRecordId as cs, AbortCommand as ct, ObligationReport as d, MAX_RECOVERY_WORK_ITEMS as da, PromptCheckpointRead as di, SubmissionLedger as dn, LifecyclePublication_d_exports as do, DurableVerifyFailure as dr, turnApprovalsBatchId as ds, AdmissionAdmitted as dt, ThreadWorkerSeal as ea, ExecutionRead as ei, ReleaseChildBudgetRequest as en, ThreadArchiveRangeSeal as eo, DurableExplainFailure as er, subagentRequestedRecordId as es, ResumePendingToolBatch as et, ObligationSeverity as f, MAX_WORK_CURSOR_CHARS as fa, PromptCheckpoints as fi, SubmissionLedgerFailure as fn, drainLifecyclePublications as fo, DurableWorkerFailure as fr, turnBatchId as fs, AdmissionConflict as ft, RecoveryExplanation as g, MAX_WORK_REBUILD_BYTES as ga, ThreadAdmission as gi, SubmissionLookupByKey as gn, MutationGate as go, RecoveryReport as gr, turnResponseBatchId as gs, AdmissionNotAdmitted as gt, RecoveryDisposition as h, MAX_WORK_PAGE_ENTRIES as ha, ThreadAbortFact as hi, SubmissionLookupById as hn, ProgressAppendRecord as ho, RecoveryFailure as hr, turnResponseBatch as hs, AdmissionIndeterminate as ht, ExplainedUnknownCall as i, getRunInput as ia, MAX_PROMPT_CHECKPOINT_RUNS as ii, ResolutionNeverHappened as in, LifecyclePublicationBatch as io, DurableResolveFailure as ir, toolApprovalRequestRecordId as is, SettleAborted as it, AwaitParentEstablishment as j, WorkStateReference as ja, ThreadMaterialization as ji, WaitingForChildSuspension as jn, childThreadIdFor as jo, RunChildAttachment as jr, DurableWorkerBinding as js, ChildReservationId as jt, AwaitChildSettlement as k, WorkIndexRebuildRequest as ka, ThreadIdentity as ki, UnknownResolutionKind as kn, approvalDecisionBatchId as ko, SubmissionStatus as kr, CurrentBindingSelection as ks, ChildBudgetReservationSnapshot as kt, ObligationBlockedOn as l, CanonicalWorkEntry as la, PromptCheckpoint as li, SettlementFinalization as ln, LifecyclePublicationSource as lo, DurableSubmitFailure as lr, toolStepSettledBatchId as ls, AbortIntent as lt, RECOVERY_DECISION_MEANINGS as m, MAX_WORK_PAGE_BYTES as ma, SelectedThreadRead as mi, SubmissionLookup as mn, lifecyclePublicationLayer as mo, RecoveryBlocked as mr, turnIdForRun as ms, AdmissionGroup as mt, ExplainedEvidence as n, canonicalBatchFitsTransfer as na, LoadCheckpointRequest as ni, ResolutionAbortSubmission as nn, ThreadArchiveStorage as no, DurableObserveOptions as nr, subagentStartedRecordId as ns, ResumeWaitingParent as nt, IntegrityCheckName as o, readWorkerState as oa, MAX_THREAD_EXPORT_PAGE_BYTES as oi, RevertJoiningRequest as on, LifecyclePublicationError as oo, DurableRuntimeConfig as or, toolCallResolvedRecordId as os, classifyRecovery as ot, ObligationThresholds as p, MAX_WORK_ENTRY_BYTES as pa, SaveCheckpointRequest as pi, SubmissionLedger_d_exports as pn, lifecyclePublicationBatchMaxFacts as po, DurableWorkerRequirements as pr, turnCanonicalBatch as ps, AdmissionFence as pt, Recovery_d_exports as q, MAX_ARCHIVE_RANGE_RECORDS as qa, ThreadStore_d_exports as qi, DurableAbortFailure as qn, runStartedBatchId as qo, validatePublication as qr, MarkJoinedRequest as qt, ExplainedSubmission as r, getRecord as ra, MAX_PROMPT_CHECKPOINT_BYTES as ri, ResolutionCompletedWithResult as rn, LifecyclePublication as ro, DurableProgressFailure as rr, toolApprovalDecisionRecordId as rs, RevertJoining as rt, IntegrityCheckStatus as s, streamExport as sa, MAX_THREAD_EXPORT_PAGE_RECORDS as si, Settlement as sn, LifecyclePublicationFact as so, DurableRuntimeConfigOptions as sr, toolCallResultBatchId as ss, pendingApprovalForRecovery as st, Admin_d_exports as t, ThreadWorkerStateRequest as ta, ExecutionUpdate as ti, ReservedChildBudget as tn, ThreadArchiveRange_d_exports as to, DurableObligationFailure as tr, subagentStartedBatchId as ts, ResumeSuspended as tt, ObligationEntry as u, MAX_RECOVERY_PAGES as ua, PromptCheckpointHead as ui, SubmissionAdmissionFence as un, LifecyclePublicationStorage as uo, DurableSubmitOptions as ur, toolStepSettledRecordId as us, AbortIntentRequest as ut, RetryRefusalReason as v, ThreadWorkCursor as va, ThreadCheckpoint as vi, SubmissionSnapshot as vn, StorageOwner as vo, RecoverySweepResult as vr, turnResultsBatchId as vs, AdmissionRequest as vt, ApplyInput as w, ThreadWork_d_exports as wa, ThreadExportRecord as wi, SuspensionSnapshot as wn, RunJournalProjection as wo, recoveryRepairRecordId as wr, AgentRegistration_d_exports as ws, ApprovalPendingSuspension as wt, predictRecoveryDisposition as x, ThreadWorkPage as xa, ThreadExport as xi, SuspendRequest as xn, JournalBoundary as xo, childReservationIdFor as xr, workerReportRecordId as xs, ApprovalConflict as xt, RetryRefused as y, ThreadWorkDiscovery as ya, ThreadCheckpoints as yi, SubmissionState as yn, StorageOwnerService as yo, WorkRecoveryReport as yr, workerInputRecordId as ys, AdmissionResolution as yt, MarkUnknown as z, encodeWorkCursor as za, ThreadRecordRequest as zi, submissionInputRecordId as zn, peerMessageRecordId as zo, makeRunWriter as zr, FundingOwner as zt };
-//# sourceMappingURL=Admin-BX9ns28E.d.mts.map
+export { ResumeFromTurnBoundary as $, ThreadArchiveRangeRead as $a, ThreadWorkerCapacityRequest as $i, DurableAwaitFailure as $n, subagentLineageBatchId as $o, ExecutionCheckpoint as $r, RecoverySnapshotRequest as $t, AwaitHostSettlement as A, WorkIndexRebuildRequest as Aa, ThreadIdentityRequest as Ai, WaitingChild as An, approvalDecisionBatchId as Ao, SubmissionStatus_d_exports as Ar, BindingUnavailable as As, ChildReservationConflict as At, NoAction as B, encodeWorkCursor as Ba, ThreadResolutionFact as Bi, submissionSettlementBatchId as Bn, modelResponseRecordId as Bo, SettlementPublication as Br, FundingOwnerRequest as Bt, renderRecoveryExplanation as C, ThreadWorkRequest as Ca, ThreadExportCursor as Ci, SuspensionReason as Cn, RunJournalContext as Co, recoveryRepairBatchId as Cr, workerReportRecordId as Cs, ApprovalDecisionIntent as Ct, AwaitApprovalDecision as D, WorkDiscoveryUnavailable as Da, ThreadExportSnapshot as Di, UnknownResolutionConflict as Dn, RunJournal_d_exports as Do, PendingSubmission as Dr, AgentAttemptContext as Ds, ChildAttachmentSnapshot as Dt, ApplyUnknownResolutions as E, WORK_INDEX_VERSION as Ea, ThreadExportRequest as Ei, UnknownResolutionCommand as En, RunJournalUsage as Eo, threadCreatedRecordId as Er, AgentRegistration_d_exports as Es, BeginChildBudgetReleaseRequest as Et, DeclaredPendingBatchEvidence as F, WorkerReportingMode as Fa, ThreadPromptRead as Fi, settlementFailureFromRecord as Fn, firstWorkerInputRecordId as Fo, RunStorageSession as Fr, ReplayVersions as Fs, Claim as Ft, RecoveryDecision as G, workIndexChanges as Ga, ThreadStoreError as Gi, workerTerminalFromRecord as Gn, runCompletedRecordId as Go, validateCanonicalSettlement as Gr, LedgerError as Gt, OpenToolCallEvidence as H, resolveWorkEvidence as Ha, ThreadSelection as Hi, submissionSettlementRecordId as Hn, projectRunJournal as Ho, SettlementPublicationFailure as Hr, JoinSnapshot as Ht, DelegationAdmissionEvidence as I, admissionWork as Ia, ThreadRead as Ii, submissionAbortBatchId as In, initialRunJournal as Io, RunWriter as Ir, ResolvedBinding as Is, ClaimHandoff as It, ReleaseOrphanChildReservation as J, MAX_ARCHIVE_RANGE_RECORDS as Ja, ThreadTail as Ji, DurableAgentRuntime as Jn, runIdForSubmission as Jo, AppendConflict as Jr, MarkReadyRequest as Jt, RecoveryEvidence as K, MAX_ARCHIVE_RANGE_BYTES as Ka, ThreadStoreFailure as Ki, ApprovalSuspensionError as Kn, runDurationBatchId as Ko, validateJoinedSettlement as Kr, MarkInputAppliedRequest as Kt, EnsureWaitingForChild as L, advanceWorkEntry as La, ThreadReadRequest as Li, submissionAbortRecordId as Ln, markUnknownBatchId as Lo, layer as Lr, compileBindingContracts as Ls, ClaimJoiningRequest as Lt, AwaitUnknownResolution as M, WorkStateReference as Ma, ThreadNotMaterialized as Mi, WorkerLedgerState as Mn, childThreadIdFor as Mo, RunChildBudgetReservation as Mr, DurableBindingFailure as Ms, ChildReservationStatus as Mt, CompleteChildAdmission as N, WorkThreadsPage as Na, ThreadObservation as Ni, WorkerStopCommand as Nn, compactionBatchId as No, RunOwnership as Nr, DurableWorkerBinding as Ns, ChildSettledNotification as Nt, AwaitChildAdmissionResolution as O, WorkIndexChange as Oa, ThreadExportSource as Oi, UnknownResolutionIntent as On, TurnCommitInput as Oo, SettledSubmission as Or, AgentRegistration as Os, ChildBudgetReservationRequest as Ot, CompleteMaterialization as P, WorkThreadsRequest as Pa, ThreadPeerCountRequest as Pi, approvalDecisionsCover as Pn, compactionRecordId as Po, RunStorage as Pr, ExecutableAgentBinding as Ps, ChildSettledOutcome as Pt, RepairSubagentStartLink as Q, ThreadArchiveRangePublish as Qa, ThreadWorkerCapacity as Qi, DurableApprovalSuspension as Qn, subagentJoinedRecordId as Qo, CommitBatch as Qr, RecoverySnapshot as Qt, FinalizeLedgerFromHistory as R, decodeWorkCursor as Ra, ThreadReader as Ri, submissionInputBatchId as Rn, modelResponseInterruptedBatchId as Ro, make as Rr, compileRegistrations as Rs, ClaimRequest as Rt, recoveryDecisionMeaning as S, ThreadWorkPage as Sa, ThreadExportBatch as Si, SuspensionOutcome as Sn, JournalBoundary as So, isolateRecovery as Sr, workerOriginRecordId as Ss, ApprovalDecisionCommand as St, ApplyJoinAccounting as T, ThreadWork_d_exports as Ta, ThreadExportRejected as Ti, UnknownResolution as Tn, RunJournalProjection as To, threadCreatedBatchId as Tr, toolCallSettledRecordId as Ts, AttachChildToReservationRequest as Tt, PendingApprovalEvidence as U, validateWorkPage as Ua, ThreadStore as Ui, unknownResolutionKind as Un, projectRunJournalStream as Uo, SettlementPublicationResult as Ur, JoiningClaim as Ut, OpenDelegationCallEvidence as V, operationEvidence as Va, ThreadRunInputRequest as Vi, submissionSettlementId as Vn, peerMessageRecordId as Vo, SettlementPublicationAuthority as Vr, InputAppliedMarker as Vt, PropagateChildAbort as W, workId as Wa, ThreadStoreDiagnostic as Wi, unknownResolutionMatchesResult as Wn, promptFromCanonicalRecords as Wo, SettlementPublisher as Wr, LedgerCapabilities as Wt, RepairJoinMarker as X, ThreadArchiveRange as Xa, ThreadVerificationRequest as Xi, DurableApprovalFailure as Xn, runStartedRecordId as Xo, AppendResult as Xr, OwnershipLost as Xt, RepairInputMarker as Y, MAX_CANONICAL_BATCH_BYTES as Ya, ThreadTailRequest as Yi, DurableAgentRuntime_d_exports as Yn, runStartedBatchId as Yo, AppendRequest as Yr, MarkUnknownRequest as Yt, RepairReadiness as Z, ThreadArchiveRangePage as Za, ThreadVerificationStorage as Zi, DurableApprovalResolver as Zn, subagentJoinBatchId as Zo, CheckpointRejected as Zr, ParentLinkage as Zt, RetryCommand as _, MAX_WORK_REBUILD_BYTES as _a, ThreadApprovalFact as _i, SubmissionScheduling as _n, MutationGate as _o, RecoverySweepOptions as _r, turnResponseBatch as _s, AdmissionPolicyError as _t, IntegrityCheck as a, makeTransferFactCheck as aa, MAX_THREAD_EXPORT_CURSOR_CHARS as ai, ResolutionSafeToRetry as an, LifecyclePublicationBatch as ao, DurableRetryFailure as ar, toolApprovalDecisionRecordId as as, SettleJoinedWithHost as at, obligationSeverityOf as b, ThreadWorkDiscovery as ba, ThreadCommands as bi, SubmissionWorkItem as bn, StorageOwnerService as bo, WorkRecoveryRequest as br, turnResultsBatchId as bs, AdmissionResult as bt, IntegrityReport as c, transferPageFits as ca, PreparedAppend as ci, SettlementConflict as cn, LifecyclePublicationFact as co, DurableSubmitAgent as cr, toolCallResolvedRecordId as cs, AbortCommand as ct, ObligationReport as d, MAX_RECOVERY_PAGES as da, PromptCheckpointRead as di, SubmissionLedger as dn, LifecyclePublicationStorage as do, DurableVerifyFailure as dr, toolStepSettledBatchId as ds, AdmissionAdmitted as dt, ThreadWorkerSeal as ea, ExecutionRead as ei, ReleaseChildBudgetRequest as en, ThreadArchiveRangeRequest as eo, DurableExplainFailure as er, subagentLineageRecordId as es, ResumePendingToolBatch as et, ObligationSeverity as f, MAX_RECOVERY_WORK_ITEMS as fa, PromptCheckpoints as fi, SubmissionLedgerFailure as fn, LifecyclePublication_d_exports as fo, DurableWorkerFailure as fr, toolStepSettledRecordId as fs, AdmissionConflict as ft, RecoveryExplanation as g, MAX_WORK_PAGE_ENTRIES as ga, ThreadAdmission as gi, SubmissionLookupByKey as gn, ProgressAppendRecord as go, RecoveryReport as gr, turnIdForRun as gs, AdmissionNotAdmitted as gt, RecoveryDisposition as h, MAX_WORK_PAGE_BYTES as ha, ThreadAbortFact as hi, SubmissionLookupById as hn, lifecyclePublicationLayer as ho, RecoveryFailure as hr, turnCanonicalBatch as hs, AdmissionIndeterminate as ht, ExplainedUnknownCall as i, getRunInput as ia, MAX_PROMPT_CHECKPOINT_RUNS as ii, ResolutionNeverHappened as in, LifecyclePublication as io, DurableResolveFailure as ir, subagentStartedRecordId as is, SettleAborted as it, AwaitParentEstablishment as j, WorkOwner as ja, ThreadMaterialization as ji, WaitingForChildSuspension as jn, childIdempotencyKeyFor as jo, RunChildAttachment as jr, CurrentBindingSelection as js, ChildReservationId as jt, AwaitChildSettlement as k, WorkIndexProgress as ka, ThreadIdentity as ki, UnknownResolutionKind as kn, agentUpdateRecordId as ko, SubmissionStatus as kr, BindingSelection as ks, ChildBudgetReservationSnapshot as kt, ObligationBlockedOn as l, CanonicalWorkEntry as la, PromptCheckpoint as li, SettlementFinalization as ln, LifecyclePublicationHandler as lo, DurableSubmitFailure as lr, toolCallResultBatchId as ls, AbortIntent as lt, RECOVERY_DECISION_MEANINGS as m, MAX_WORK_ENTRY_BYTES as ma, SelectedThreadRead as mi, SubmissionLookup as mn, lifecyclePublicationBatchMaxFacts as mo, RecoveryBlocked as mr, turnBatchId as ms, AdmissionGroup as mt, ExplainedEvidence as n, canonicalBatchFitsTransfer as na, LoadCheckpointRequest as ni, ResolutionAbortSubmission as nn, ThreadArchiveRange_d_exports as no, DurableObserveOptions as nr, subagentRequestedRecordId as ns, ResumeWaitingParent as nt, IntegrityCheckName as o, readWorkerState as oa, MAX_THREAD_EXPORT_PAGE_BYTES as oi, RevertJoiningRequest as on, LifecyclePublicationConfig as oo, DurableRuntimeConfig as or, toolApprovalRequestRecordId as os, classifyRecovery as ot, ObligationThresholds as p, MAX_WORK_CURSOR_CHARS as pa, SaveCheckpointRequest as pi, SubmissionLedger_d_exports as pn, drainLifecyclePublications as po, DurableWorkerRequirements as pr, turnApprovalsBatchId as ps, AdmissionFence as pt, Recovery_d_exports as q, MAX_ARCHIVE_RANGE_PAGE as qa, ThreadStore_d_exports as qi, DurableAbortFailure as qn, runDurationRecordId as qo, validatePublication as qr, MarkJoinedRequest as qt, ExplainedSubmission as r, getRecord as ra, MAX_PROMPT_CHECKPOINT_BYTES as ri, ResolutionCompletedWithResult as rn, ThreadArchiveStorage as ro, DurableProgressFailure as rr, subagentStartedBatchId as rs, RevertJoining as rt, IntegrityCheckStatus as s, streamExport as sa, MAX_THREAD_EXPORT_PAGE_RECORDS as si, Settlement as sn, LifecyclePublicationError as so, DurableRuntimeConfigOptions as sr, toolCallResolutionBatchId as ss, pendingApprovalForRecovery as st, Admin_d_exports as t, ThreadWorkerStateRequest as ta, ExecutionUpdate as ti, ReservedChildBudget as tn, ThreadArchiveRangeSeal as to, DurableObligationFailure as tr, subagentRequestedBatchId as ts, ResumeSuspended as tt, ObligationEntry as u, FreshAdmissionWork as ua, PromptCheckpointHead as ui, SubmissionAdmissionFence as un, LifecyclePublicationSource as uo, DurableSubmitOptions as ur, toolCallUnknownRecordId as us, AbortIntentRequest as ut, RetryRefusalReason as v, MAX_WORK_REBUILD_RECORDS as va, ThreadCheckpoint as vi, SubmissionSnapshot as vn, OwnerGeneration as vo, RecoverySweepResult as vr, turnResponseBatchId as vs, AdmissionRequest as vt, ApplyInput as w, ThreadWorkStorage as wa, ThreadExportRecord as wi, SuspensionSnapshot as wn, RunJournalError as wo, recoveryRepairRecordId as wr, JournalRecordEnvelope as ws, ApprovalPendingSuspension as wt, predictRecoveryDisposition as x, ThreadWorkEntry as xa, ThreadExport as xi, SuspendRequest as xn, makeStorageOwner as xo, childReservationIdFor as xr, workerInputRecordId as xs, ApprovalConflict as xt, RetryRefused as y, ThreadWorkCursor as ya, ThreadCheckpoints as yi, SubmissionState as yn, StorageOwner as yo, WorkRecoveryReport as yr, turnResultsBatch as ys, AdmissionResolution as yt, MarkUnknown as z, deliveryPredecessor as za, ThreadRecordRequest as zi, submissionInputRecordId as zn, modelResponseInterruptedRecordId as zo, makeRunWriter as zr, definitionDigestsEqual as zs, FundingOwner as zt };
+//# sourceMappingURL=Admin-Qa3I1oA5.d.mts.map

package/dist/{Agent-9aBoIi74.d.mts → Agent-B39jRnFv.d.mts}

@@ -264,7 +264,7 @@ declare function make<const Name extends string, InputSchema extends Schema.Top,
   readonly id: AgentId & Name;
 };
 /** Bind a native model or thread resolver without acquiring or hiding its requirements. */
-declare const withModel: <DefinitionValue extends AnyDefinition, ModelValue>(definition: DefinitionValue, model: NativeModel<ModelValue>) => Binding<DefinitionValue, ModelValue>;
+declare function withModel<DefinitionValue extends AnyDefinition, ModelValue>(definition: DefinitionValue, model: NativeModel<ModelValue>): Binding<DefinitionValue, ModelValue>;
 //#endregion
 export { ToolUnion as A, OutputSchema as C, RunDispositionFailure as D, RunDispositionDeclaration as E, isModelResolver as F, make as I, withModel as L, Update as M, UpdatesSchema as N, RunDispositionSchema as O, inspectTools as P, Output as S, RunDisposition as T, InstructionSource as _, CompletionFromToolDeclaration as a, Name as b, Definition as c, EncodedInput as d, Failure as f, InstructionResult as g, InputSchema as h, Binding as i, Tools as j, ToolInspection as k, DefinitionOptions as l, InputPromptSource as m, Any as n, CompletionProjectionInput as o, Input as p, AnyDefinition as r, CompletionToolDeclaration as s, Agent_d_exports as t, DefinitionRequirements as u, ModelResolver as v, Requirements as w, NativeModel as x, ModelServices as y };
-//# sourceMappingURL=Agent-9aBoIi74.d.mts.map
+//# sourceMappingURL=Agent-B39jRnFv.d.mts.map

package/dist/{Agent-0WvBWWbM.mjs → Agent-BiRbr73L.mjs}

@@ -82,12 +82,13 @@ function make(id, options) {
 		runDisposition: options.runDisposition === void 0 ? void 0 : Object.freeze({ ...options.runDisposition })
 	});
 }
-/** Bind a native model or thread resolver without acquiring or hiding its requirements. */
-const withModel = (definition, model) => Object.freeze({
-	definition,
-	model
-});
+function withModel(definition, model) {
+	return Object.freeze({
+		definition,
+		model
+	});
+}
 //#endregion
 export { make as a, isModelResolver as i, ToolInspection as n, withModel as o, inspectTools as r, Agent_exports as t };
 
-//# sourceMappingURL=Agent-0WvBWWbM.mjs.map
+//# sourceMappingURL=Agent-BiRbr73L.mjs.map

package/dist/Agent-BiRbr73L.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Agent-BiRbr73L.mjs","names":["S"],"sources":["../src/core/internal/agent-updates.ts","../src/core/Agent.ts"],"sourcesContent":["import * as Tool from \"effect/ai/Tool\";\nimport * as Toolkit from \"effect/ai/Toolkit\";\nimport * as Schema from \"effect/Schema\";\n\nimport { Emitter, UpdateError } from \"../AgentUpdates.ts\";\n\n/** Definition-owned native Tool. Runtime supplies its handler under the same identity. */\nexport const updateTool = <S extends Schema.Top>(schema: S) =>\n  Tool.make(\"emit_update\", {\n    description:\n      \"Emit a structured intermediate update. Success acknowledges acceptance by this Run; \" +\n      \"parent delivery and processing are separate. This does not complete the task.\",\n    parameters: Schema.Struct({ value: schema }),\n    success: Schema.Struct({ emitted: Schema.Literal(true) }),\n    failure: UpdateError,\n    failureMode: \"return\",\n  }).addDependency(Emitter);\n\nexport type UpdateToolkit<\n  T extends Toolkit.Any,\n  S extends Schema.Top | undefined,\n> = S extends Schema.Top\n  ? Toolkit.Toolkit<T[\"tools\"] & { readonly emit_update: ReturnType<typeof updateTool<S>> }>\n  : T;\n\nexport const withUpdateTool = (\n  toolkit: Toolkit.Any,\n  schema: Schema.Top | undefined,\n): Toolkit.Any => {\n  if (schema === undefined) return toolkit;\n  if (Object.hasOwn(toolkit.tools, \"emit_update\"))\n    // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Agent.make synchronously rejects a toolkit that occupies the reserved update Tool name.\n    throw new TypeError(\"emit_update is reserved for Agent updates\");\n\n  return Toolkit.make(...Object.values(toolkit.tools), updateTool(schema));\n};\n","import type { Effect, Layer, Option, Schema } from \"effect\";\nimport type { AiError, LanguageModel, Model, Prompt } from \"effect/ai\";\nimport * as Tool from \"effect/ai/Tool\";\nimport * as Toolkit from \"effect/ai/Toolkit\";\nimport * as S from \"effect/Schema\";\n\nimport type {\n  AgentInputDecodeError,\n  AgentInputError,\n  AgentOutputError,\n  AgentRunDispositionError,\n} from \"./AgentError.ts\";\nimport { AgentPolicy, type AgentPolicyInput } from \"./AgentPolicy.ts\";\nimport { AgentId } from \"./Identifiers.ts\";\nimport { type UpdateToolkit, withUpdateTool } from \"./internal/agent-updates.ts\";\nimport type { Configuration } from \"./ToolExposure.ts\";\n\n/** Prompt input produced directly or by an Effect that preserves its failure and requirements. */\nexport type InstructionResult<E = never, R = never> =\n  | Prompt.RawInput\n  | Effect.Effect<Prompt.RawInput, E, R>;\n\n/** Static prompt input or an input-dependent source evaluated once while preparing a run. */\nexport type InstructionSource<Input, E = never, R = never> =\n  | Prompt.RawInput\n  | ((input: Input) => InstructionResult<E, R>);\n\n/** Definition-owned projection from decoded Agent input to model-visible prompt content. */\nexport type InputPromptSource<Input, E = never, R = never> = (\n  input: Input,\n) => InstructionResult<E, R>;\n\n/** Native services needed to execute and identify model calls. */\nexport type ModelServices = LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName;\n\n/**\n * An optional capability on a provided LanguageModel service. The runtime supplies\n * only model-visible task context and eligible Tool descriptions after validating input.\n * The resolver owns retaining one choice per Thread, including across Runs and\n * recovery; it captures client requirements and returns a closed native Layer\n * that the interpreter acquires for the Run. Context hooks may prepare prompts\n * but cannot replace this model through a per-Turn modelCall.\n * Selection failures remain AiError values and all selector/client services stay in R.\n */\nexport interface ModelResolver extends LanguageModel.LanguageModel {\n  readonly resolve: (request: {\n    readonly threadId: string;\n    readonly state: Schema.JsonObject;\n  }) => Effect.Effect<Layer.Layer<ModelServices>, AiError.AiError>;\n}\n\n/** Detect the deferred resolver capability on a trusted, host-provided model service. */\nexport const isModelResolver = (model: LanguageModel.LanguageModel): model is ModelResolver =>\n  \"resolve\" in model && typeof model.resolve === \"function\";\n\n/** Accepts native model Layers that provide generation and model identity. */\nexport type NativeModel<ModelValue> =\n  ModelValue extends Layer.Layer<infer Provides, never, infer _Requires>\n    ? ModelServices extends Provides\n      ? ModelValue\n      : never\n    : never;\n\n/** Definition-owned boundary for selecting and validating an application run disposition. */\nexport interface RunDispositionDeclaration<Output, DispositionSchema extends Schema.Top> {\n  /**\n   * Opt background workers into one retained assignment. The encoded disposition must be\n   * Worker.AssignmentDisposition: completed seals the worker, waiting leaves it steerable.\n   * Failures and exhausted Runs seal as failed; aborting an active Run seals as cancelled.\n   * The worker origin retains this choice. Omission preserves reusable workers.\n   */\n  readonly workerLifecycle?: \"assignment\" | undefined;\n  /** Canonical Schema used to validate and encode the selected disposition. */\n  readonly schema: DispositionSchema;\n  /** Pure selection from decoded output. `undefined` declares none, except for assignments. */\n  readonly fromOutput: (output: Output) => unknown;\n}\n\n/** Values available to a Definition-owned completion Tool projector after canonical decoding. */\nexport interface CompletionProjectionInput<Parameters = unknown, Result = unknown> {\n  readonly parameters: Parameters;\n  readonly result: Result;\n}\n\n/**\n * One application Tool whose successful result can complete its owning Agent when it is the\n * only application call. Provider-executed calls may accompany it only with terminal results.\n * Mixed, wholly unexecuted application batches are rejected with failed Tool results so the\n * model can correct them within ordinary Run budgets; completed provider results are retained.\n * Missing provider results and invalid pending resumed batches fail closed. The completion\n * designation never permits side-effect replay.\n */\nexport interface CompletionToolDeclaration<\n  Parameters = unknown,\n  Result = unknown,\n  Output = unknown,\n> {\n  readonly tool: string;\n  /** Require native Tool use on every model Turn and this Tool for final completion. */\n  readonly required?: boolean | undefined;\n  /**\n   * Pure, deterministic projection: recovery may reevaluate a recorded Tool result before\n   * RunCompleted commits. Once committed, that stored output wins across later code changes.\n   */\n  readonly project: (input: CompletionProjectionInput<Parameters, Result>) => Output;\n}\n\ntype CompletionToolFor<ToolkitValue extends Toolkit.Any, Output> = {\n  readonly [Name in keyof ToolkitValue[\"tools\"] & string]: CompletionToolDeclaration<\n    Tool.Parameters<ToolkitValue[\"tools\"][Name]>,\n    Tool.Success<ToolkitValue[\"tools\"][Name]>,\n    Output\n  > & { readonly tool: Name };\n}[keyof ToolkitValue[\"tools\"] & string];\n\n/**\n * An ordinary action Tool whose canonical success may satisfy the whole request.\n * Projectors must be pure and deterministic: recovery re-evaluates them. None preserves\n * ordinary continuation; Some is validated as the Agent output. These Tools must be the sole\n * application call; terminal provider results may accompany them. They never receive the\n * required completion Tool's exhaustion allowance.\n */\nexport interface CompletionFromToolDeclaration<\n  Parameters = unknown,\n  Result = unknown,\n  Output = unknown,\n> {\n  readonly tool: string;\n  readonly project: (input: CompletionProjectionInput<Parameters, Result>) => Option.Option<Output>;\n}\n\ntype CompletionFromToolFor<ToolkitValue extends Toolkit.Any, Output> = {\n  readonly [Name in keyof ToolkitValue[\"tools\"] & string]: CompletionFromToolDeclaration<\n    Tool.Parameters<ToolkitValue[\"tools\"][Name]>,\n    Tool.Success<ToolkitValue[\"tools\"][Name]>,\n    Output\n  > & { readonly tool: Name };\n}[keyof ToolkitValue[\"tools\"] & string];\n\n/** Immutable, model-agnostic schemas, behavior, tools, and bounds for an agent. */\nexport interface Definition<\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions,\n  ToolkitValue extends Toolkit.Any,\n  RunDispositionValue = undefined,\n  InputPromptValue = undefined,\n  UpdatesSchema extends Schema.Top | undefined = undefined,\n> {\n  /** Stable agent identity; changing it creates a distinct definition identity. */\n  readonly id: AgentId;\n  /** Canonical Schema for intermediate updates emitted by this Agent. */\n  readonly updates?: UpdatesSchema;\n  /** Canonical schema used to decode and encode run input. */\n  readonly input: InputSchema;\n  /** Canonical schema used to decode the final model output. */\n  readonly output: OutputSchema;\n  /**\n   * Evaluated once while preparing each Run. OpenAI, xAI and native adapters advertising support\n   * preserve chronological system messages, omitting exact repeats only when no distinct system\n   * instruction intervenes. The actual selected model determines support on each call. Other\n   * adapters group systems first and keep the last exact repeat, including provider options;\n   * Anthropic requires an upstream adapter with mid-conversation system-message support.\n   * Stored history is unchanged.\n   */\n  readonly instructions: Instructions;\n  /**\n   * Optional projection from decoded input to model-visible native Effect AI prompt content.\n   * This controls disclosure only: durable admission retains the complete input and Tool\n   * authorization receives it. A projection failure never falls back to sending full input.\n   */\n  readonly inputPrompt?: InputPromptValue | undefined;\n  /** Native Effect AI toolkit whose failures and requirements remain visible. */\n  readonly toolkit: ToolkitValue;\n  readonly toolExposure?: Configuration | undefined;\n  /** Finite execution bounds enforced by the runtime. */\n  readonly policy: AgentPolicy;\n  /** Explicit policy fields, retained so delegated runs can inherit omitted fields. */\n  readonly policyOverrides?: Partial<AgentPolicyInput> | undefined;\n  /** Optional successful Tool result that projects directly to the Agent output and settles. */\n  readonly completion?: CompletionToolDeclaration | undefined;\n  readonly completionFromTools?: ReadonlyArray<CompletionFromToolDeclaration> | undefined;\n  readonly runDisposition?: RunDispositionValue | undefined;\n  readonly description?: string | undefined;\n  readonly metadata?: Readonly<Record<string, string>> | undefined;\n}\n\n/** Options for a model-agnostic agent definition. */\nexport interface DefinitionOptions<\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions extends InstructionSource<InputSchema[\"Type\"], unknown, unknown>,\n  ToolkitValue extends Toolkit.Any,\n  RunDispositionValue extends\n    | RunDispositionDeclaration<OutputSchema[\"Type\"], Schema.Top>\n    | undefined = undefined,\n  InputPromptValue extends InputPromptSource<InputSchema[\"Type\"], unknown, unknown> | undefined =\n    undefined,\n  UpdatesSchema extends Schema.Top | undefined = undefined,\n> {\n  readonly updates?: UpdatesSchema;\n  readonly input: InputSchema;\n  readonly output: OutputSchema;\n  readonly instructions: Instructions;\n  readonly inputPrompt?: InputPromptValue | undefined;\n  readonly toolkit: ToolkitValue;\n  readonly toolExposure?: Configuration | undefined;\n  readonly policy?: Partial<AgentPolicyInput> | undefined;\n  readonly completion?: CompletionToolFor<ToolkitValue, OutputSchema[\"Type\"]> | undefined;\n  readonly completionFromTools?:\n    | ReadonlyArray<CompletionFromToolFor<ToolkitValue, OutputSchema[\"Type\"]>>\n    | undefined;\n  readonly runDisposition?: RunDispositionValue | undefined;\n  readonly description?: string | undefined;\n  readonly metadata?: Readonly<Record<string, string>> | undefined;\n}\n\ntype AnyDefinitionShape = Definition<\n  Schema.Top,\n  Schema.Top,\n  unknown,\n  Toolkit.Any,\n  RunDispositionDeclaration<never, Schema.Top> | undefined,\n  unknown,\n  Schema.Top | undefined\n>;\n\n/** Immutable pairing of an agent definition with a native model Layer or thread resolver. */\nexport interface Binding<DefinitionValue extends AnyDefinitionShape, ModelValue> {\n  readonly definition: DefinitionValue;\n  readonly model: NativeModel<ModelValue>;\n}\n\ntype InstructionEffect<Instructions, Input> = Instructions extends (input: Input) => infer Result\n  ? Result\n  : Instructions;\n\ntype InputPromptEffect<InputPrompt, Input> = InputPrompt extends (input: Input) => infer Result\n  ? Result\n  : never;\n\ntype EffectError<Value> =\n  Value extends Effect.Effect<infer _Success, infer Error, infer _Services> ? Error : never;\n\ntype EffectServices<Value> =\n  Value extends Effect.Effect<infer _Success, infer _Error, infer Services> ? Services : never;\n\ntype ModelRequirements<Value> =\n  Value extends Layer.Layer<infer _Provides, infer _Error, infer Services> ? Services : never;\n\n/** Constructors and type projections for definitions and runnable model bindings. */\n\n/** Type-erased definition used at generic framework boundaries. */\nexport type AnyDefinition = AnyDefinitionShape;\n\n/** Read-only interpreter program or binding used at inspection and projection boundaries. */\nexport interface Any {\n  readonly definition: AnyDefinition;\n  readonly model?: unknown;\n}\n\n/** Native Tool configuration for inspection; it does not predict an invocation's outcome. */\nexport const ToolInspection = S.Struct({\n  name: S.String,\n  failureMode: S.Literals([\"error\", \"return\"]),\n  /** False for provider-executed Tools, whose results do not pass through local handlers. */\n  requiresHandler: S.Boolean,\n});\n\nexport type ToolInspection = typeof ToolInspection.Type;\n\n/**\n * Inspect registered native Tools in declaration order without acquiring handlers or a Model.\n * This is the full Definition toolkit, before run-specific visibility or exposure filtering.\n * `failureMode` is Effect AI's configured mode, including its `\"error\"` default. Handler-level\n * recovery, programmatic invocation and Subagent containment can change where failures go;\n * consult execution diagnostics for the actual route. No arguments, results or services are read.\n */\nexport const inspectTools = (agent: AnyDefinition | Any): ReadonlyArray<ToolInspection> => {\n  const definition = \"definition\" in agent ? agent.definition : agent;\n\n  return Object.values(definition.toolkit.tools).map((tool) =>\n    ToolInspection.make({\n      name: tool.name,\n      failureMode: tool.failureMode,\n      requiresHandler: !Tool.isProviderDefined(tool) || tool.requiresHandler,\n    }),\n  );\n};\n\ntype DefinitionOf<AgentValue extends AnyDefinition | Any> = AgentValue extends {\n  readonly definition: infer DefinitionValue extends AnyDefinition;\n}\n  ? DefinitionValue\n  : AgentValue;\n\ntype RunDispositionSchemaOf<DefinitionValue extends AnyDefinition> = [\n  Exclude<DefinitionValue[\"runDisposition\"], undefined>,\n] extends [never]\n  ? never\n  : Exclude<DefinitionValue[\"runDisposition\"], undefined> extends RunDispositionDeclaration<\n        never,\n        infer DispositionSchema\n      >\n    ? DispositionSchema\n    : never;\n\n/** Literal Agent ID, retained by Agent.make. */\nexport type Name<A extends AnyDefinition | Any> = DefinitionOf<A>[\"id\"] extends AgentId &\n  (infer N extends string)\n  ? N\n  : string;\n\n/** Declared update Schema, or never for Agents without updates. */\nexport type UpdatesSchema<A extends AnyDefinition | Any> = Exclude<\n  DefinitionOf<A>[\"updates\"],\n  undefined\n>;\n\n/** Decoded intermediate update value. */\nexport type Update<A extends AnyDefinition | Any> = UpdatesSchema<A>[\"Type\"];\n\n/** Decoded input type of a definition or binding. */\nexport type Input<AgentValue extends AnyDefinition | Any> =\n  DefinitionOf<AgentValue>[\"input\"][\"Type\"];\n\n/** Encoded input accepted by the primary execution operations. */\nexport type EncodedInput<AgentValue extends AnyDefinition | Any> =\n  DefinitionOf<AgentValue>[\"input\"][\"Encoded\"];\n\n/** Decoded output type of a definition or binding. */\nexport type Output<AgentValue extends AnyDefinition | Any> =\n  DefinitionOf<AgentValue>[\"output\"][\"Type\"];\n\n/** Input Schema carried by a definition or binding. */\nexport type InputSchema<AgentValue extends AnyDefinition | Any> = DefinitionOf<AgentValue>[\"input\"];\n\n/** Output Schema carried by a definition or binding. */\nexport type OutputSchema<AgentValue extends AnyDefinition | Any> =\n  DefinitionOf<AgentValue>[\"output\"];\n\n/** Application run-disposition Schema carried by a definition or binding, or `never`. */\nexport type RunDispositionSchema<AgentValue extends AnyDefinition | Any> = RunDispositionSchemaOf<\n  DefinitionOf<AgentValue>\n>;\n\n/** Decoded application run disposition declared by a definition or binding. */\nexport type RunDisposition<AgentValue extends AnyDefinition | Any> = [\n  RunDispositionSchema<AgentValue>,\n] extends [never]\n  ? never\n  : RunDispositionSchema<AgentValue>[\"Type\"];\n\n/** Validation failure admitted only by definitions that declare a run disposition. */\nexport type RunDispositionFailure<AgentValue extends AnyDefinition | Any> = [\n  RunDispositionSchemaOf<DefinitionOf<AgentValue>>,\n] extends [never]\n  ? never\n  : AgentRunDispositionError;\n\n/** Effect AI tool map carried by a definition or binding. */\nexport type Tools<AgentValue extends AnyDefinition | Any> = Toolkit.Tools<\n  DefinitionOf<AgentValue>[\"toolkit\"]\n>;\n\ntype ApplicationTools<A extends AnyDefinition> = [UpdatesSchema<A>] extends [never]\n  ? Tools<A>\n  : Omit<Tools<A>, \"emit_update\">;\n\ntype ToolMapValues<ToolMap extends Record<string, Tool.Any>> = ToolMap extends unknown\n  ? ToolMap[keyof ToolMap]\n  : never;\n\n/** All possible tools, including keys present in only one definition or binding branch. */\nexport type ToolUnion<AgentValue extends AnyDefinition | Any> = ToolMapValues<Tools<AgentValue>>;\n\n/** Instruction, tool-handler, and Schema services required before a Model is bound. */\nexport type DefinitionRequirements<DefinitionValue extends AnyDefinition> =\n  DefinitionValue extends unknown\n    ?\n        | EffectServices<InstructionEffect<DefinitionValue[\"instructions\"], Input<DefinitionValue>>>\n        | EffectServices<InputPromptEffect<DefinitionValue[\"inputPrompt\"], Input<DefinitionValue>>>\n        | Tool.HandlersFor<ApplicationTools<DefinitionValue>>\n        | Tool.HandlerServices<ToolMapValues<ApplicationTools<DefinitionValue>>>\n        // The interpreter canonically re-encodes decoded Tool parameters before recording them.\n        | Tool.ParametersSchema<ToolUnion<DefinitionValue>>[\"EncodingServices\"]\n        | Tool.SuccessSchema<ToolUnion<DefinitionValue>>[\"DecodingServices\"]\n        | DefinitionValue[\"input\"][\"DecodingServices\"]\n        | DefinitionValue[\"input\"][\"EncodingServices\"]\n        | DefinitionValue[\"output\"][\"DecodingServices\"]\n        | DefinitionValue[\"output\"][\"EncodingServices\"]\n        | UpdatesSchema<DefinitionValue>[\"DecodingServices\"]\n        | UpdatesSchema<DefinitionValue>[\"EncodingServices\"]\n        | RunDispositionSchemaOf<DefinitionValue>[\"DecodingServices\"]\n        | RunDispositionSchemaOf<DefinitionValue>[\"EncodingServices\"]\n    : never;\n\n/** Definition services plus native model services, or a binding's model Layer requirements. */\nexport type Requirements<AgentValue extends AnyDefinition | Any> =\n  | DefinitionRequirements<DefinitionOf<AgentValue>>\n  | (AgentValue extends { readonly model: infer ModelValue }\n      ? ModelRequirements<ModelValue>\n      : ModelServices);\n\n// Distribute after unwrapping bindings too: withModel may itself contain a definition union.\ntype DefinitionFailure<DefinitionValue extends AnyDefinition> = DefinitionValue extends unknown\n  ?\n      | EffectError<InstructionEffect<DefinitionValue[\"instructions\"], Input<DefinitionValue>>>\n      | EffectError<InputPromptEffect<DefinitionValue[\"inputPrompt\"], Input<DefinitionValue>>>\n      | Tool.HandlerError<ToolUnion<DefinitionValue>>\n  : never;\n\n/** Failures from every possible definition, preserving each branch's instruction input type. */\nexport type Failure<AgentValue extends AnyDefinition | Any> =\n  | DefinitionFailure<DefinitionOf<AgentValue>>\n  | AiError.AiError\n  | AgentInputDecodeError\n  | AgentInputError\n  | AgentOutputError\n  | RunDispositionFailure<AgentValue>;\n\n/** Validate an agent ID and return a shallowly frozen, model-agnostic definition. */\nexport function make<\n  const Name extends string,\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions extends InstructionSource<InputSchema[\"Type\"], unknown, unknown>,\n  ToolkitValue extends Toolkit.Any,\n  DispositionSchema extends Schema.Top,\n  InputPromptValue extends InputPromptSource<InputSchema[\"Type\"], unknown, unknown> | undefined,\n  UpdatesSchema extends Schema.Top | undefined = undefined,\n>(\n  id: Name,\n  options: DefinitionOptions<\n    InputSchema,\n    OutputSchema,\n    Instructions,\n    ToolkitValue,\n    RunDispositionDeclaration<OutputSchema[\"Type\"], DispositionSchema>,\n    InputPromptValue,\n    UpdatesSchema\n  > & {\n    readonly runDisposition: RunDispositionDeclaration<OutputSchema[\"Type\"], DispositionSchema>;\n    readonly inputPrompt: InputPromptValue;\n  },\n): Definition<\n  InputSchema,\n  OutputSchema,\n  Instructions,\n  UpdateToolkit<ToolkitValue, NoInfer<UpdatesSchema>>,\n  RunDispositionDeclaration<OutputSchema[\"Type\"], DispositionSchema>,\n  InputPromptValue,\n  NoInfer<UpdatesSchema>\n> & { readonly id: AgentId & Name };\n\nexport function make<\n  const Name extends string,\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions extends InstructionSource<InputSchema[\"Type\"], unknown, unknown>,\n  ToolkitValue extends Toolkit.Any,\n  DispositionSchema extends Schema.Top,\n  UpdatesSchema extends Schema.Top | undefined = undefined,\n>(\n  id: Name,\n  options: DefinitionOptions<\n    InputSchema,\n    OutputSchema,\n    Instructions,\n    ToolkitValue,\n    RunDispositionDeclaration<OutputSchema[\"Type\"], DispositionSchema>,\n    undefined,\n    UpdatesSchema\n  > & {\n    readonly runDisposition: RunDispositionDeclaration<OutputSchema[\"Type\"], DispositionSchema>;\n    readonly inputPrompt?: undefined;\n  },\n): Definition<\n  InputSchema,\n  OutputSchema,\n  Instructions,\n  UpdateToolkit<ToolkitValue, NoInfer<UpdatesSchema>>,\n  RunDispositionDeclaration<OutputSchema[\"Type\"], DispositionSchema>,\n  undefined,\n  NoInfer<UpdatesSchema>\n> & { readonly id: AgentId & Name };\n\nexport function make<\n  const Name extends string,\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions extends InstructionSource<InputSchema[\"Type\"], unknown, unknown>,\n  ToolkitValue extends Toolkit.Any,\n  InputPromptValue extends InputPromptSource<InputSchema[\"Type\"], unknown, unknown> | undefined,\n  UpdatesSchema extends Schema.Top | undefined = undefined,\n>(\n  id: Name,\n  options: DefinitionOptions<\n    InputSchema,\n    OutputSchema,\n    Instructions,\n    ToolkitValue,\n    undefined,\n    InputPromptValue,\n    UpdatesSchema\n  > & {\n    readonly inputPrompt: InputPromptValue;\n    readonly runDisposition?: undefined;\n  },\n): Definition<\n  InputSchema,\n  OutputSchema,\n  Instructions,\n  UpdateToolkit<ToolkitValue, NoInfer<UpdatesSchema>>,\n  undefined,\n  InputPromptValue,\n  NoInfer<UpdatesSchema>\n> & { readonly id: AgentId & Name };\n\nexport function make<\n  const Name extends string,\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions extends InstructionSource<InputSchema[\"Type\"], unknown, unknown>,\n  ToolkitValue extends Toolkit.Any,\n  UpdatesSchema extends Schema.Top | undefined = undefined,\n>(\n  id: Name,\n  options: DefinitionOptions<\n    InputSchema,\n    OutputSchema,\n    Instructions,\n    ToolkitValue,\n    undefined,\n    undefined,\n    UpdatesSchema\n  > & {\n    readonly inputPrompt?: undefined;\n    readonly runDisposition?: undefined;\n  },\n): Definition<\n  InputSchema,\n  OutputSchema,\n  Instructions,\n  UpdateToolkit<ToolkitValue, NoInfer<UpdatesSchema>>,\n  undefined,\n  undefined,\n  NoInfer<UpdatesSchema>\n> & { readonly id: AgentId & Name };\n\nexport function make(\n  id: string,\n  options: {\n    readonly updates?: Schema.Top | undefined;\n    readonly input: Schema.Top;\n    readonly output: Schema.Top;\n    readonly instructions: unknown;\n    readonly inputPrompt?: unknown;\n    readonly toolkit: Toolkit.Any;\n    readonly toolExposure?: Configuration | undefined;\n    readonly policy?: Partial<AgentPolicyInput> | undefined;\n    readonly completion?: CompletionToolDeclaration | undefined;\n    readonly completionFromTools?: ReadonlyArray<CompletionFromToolDeclaration> | undefined;\n    readonly runDisposition?: RunDispositionDeclaration<never, Schema.Top> | undefined;\n    readonly description?: string | undefined;\n    readonly metadata?: Readonly<Record<string, string>> | undefined;\n  },\n): AnyDefinition {\n  const completionNames = new Set<string>();\n\n  for (const declaration of options.completionFromTools ?? []) {\n    if (declaration.tool === options.completion?.tool || completionNames.has(declaration.tool)) {\n      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Agent.make synchronously rejects duplicate completion declarations before constructing the Definition.\n      throw new Error(`Tool ${declaration.tool} has more than one completion declaration`);\n    }\n    if (!Object.hasOwn(options.toolkit.tools, declaration.tool)) {\n      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Agent.make synchronously rejects completion declarations for absent Tools.\n      throw new Error(`Unknown completion Tool ${declaration.tool}`);\n    }\n    completionNames.add(declaration.tool);\n  }\n\n  const tools = Object.values(options.toolkit.tools);\n\n  const readonlyTools = tools.map((tool) =>\n    Tool.isProviderDefined(tool) &&\n    !tool.requiresHandler &&\n    [\"web_search\", \"web_search_preview\", \"file_search\"].includes(tool.providerName)\n      ? tool.annotate(Tool.Readonly, true)\n      : tool,\n  );\n\n  const toolkit = readonlyTools.some((tool, index) => tool !== tools[index])\n    ? Toolkit.make(...readonlyTools)\n    : options.toolkit;\n\n  return Object.freeze({\n    ...options,\n    toolkit: withUpdateTool(toolkit, options.updates),\n    policy: AgentPolicy.resolve(options.policy),\n    policyOverrides: Object.freeze({ ...options.policy }),\n    toolExposure:\n      options.toolExposure === undefined\n        ? undefined\n        : Object.freeze({\n            ...options.toolExposure,\n            initialToolNames: Object.freeze([...(options.toolExposure.initialToolNames ?? [])]),\n          }),\n    id: S.decodeSync(AgentId)(id),\n    metadata: options.metadata === undefined ? undefined : Object.freeze({ ...options.metadata }),\n    completion:\n      options.completion === undefined ? undefined : Object.freeze({ ...options.completion }),\n    completionFromTools:\n      options.completionFromTools === undefined\n        ? undefined\n        : Object.freeze(\n            options.completionFromTools.map((declaration) => Object.freeze({ ...declaration })),\n          ),\n    runDisposition:\n      options.runDisposition === undefined\n        ? undefined\n        : Object.freeze({ ...options.runDisposition }),\n  });\n}\n\n/** Bind a native model or thread resolver without acquiring or hiding its requirements. */\nexport function withModel<DefinitionValue extends AnyDefinition, ModelValue>(\n  definition: DefinitionValue,\n  model: NativeModel<ModelValue>,\n): Binding<DefinitionValue, ModelValue>;\n\nexport function withModel<DefinitionValue extends AnyDefinition, ModelValue>(\n  definition: DefinitionValue,\n  model: ModelValue,\n) {\n  return Object.freeze({ definition, model });\n}\n"],"mappings":";;;;;;;;;AAOA,MAAa,cAAoC,WAC/C,KAAK,KAAK,eAAe;CACvB,aACE;CAEF,YAAY,OAAO,OAAO,EAAE,OAAO,OAAO,CAAC;CAC3C,SAAS,OAAO,OAAO,EAAE,SAAS,OAAO,QAAQ,IAAI,EAAE,CAAC;CACxD,SAAS;CACT,aAAa;AACf,CAAC,CAAC,CAAC,cAAc,OAAO;AAS1B,MAAa,kBACX,SACA,WACgB;CAChB,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,IAAI,OAAO,OAAO,QAAQ,OAAO,aAAa,GAE5C,MAAM,IAAI,UAAU,2CAA2C;CAEjE,OAAO,QAAQ,KAAK,GAAG,OAAO,OAAO,QAAQ,KAAK,GAAG,WAAW,MAAM,CAAC;AACzE;;;;;;;;;;;ACiBA,MAAa,mBAAmB,UAC9B,aAAa,SAAS,OAAO,MAAM,YAAY;;AAiNjD,MAAa,iBAAiBA,OAAE,OAAO;CACrC,MAAMA,OAAE;CACR,aAAaA,OAAE,SAAS,CAAC,SAAS,QAAQ,CAAC;;CAE3C,iBAAiBA,OAAE;AACrB,CAAC;;;;;;;;AAWD,MAAa,gBAAgB,UAA8D;CACzF,MAAM,aAAa,gBAAgB,QAAQ,MAAM,aAAa;CAE9D,OAAO,OAAO,OAAO,WAAW,QAAQ,KAAK,CAAC,CAAC,KAAK,SAClD,eAAe,KAAK;EAClB,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,iBAAiB,CAAC,KAAK,kBAAkB,IAAI,KAAK,KAAK;CACzD,CAAC,CACH;AACF;AAsQA,SAAgB,KACd,IACA,SAee;CACf,MAAM,kCAAkB,IAAI,IAAY;CAExC,KAAK,MAAM,eAAe,QAAQ,uBAAuB,CAAC,GAAG;EAC3D,IAAI,YAAY,SAAS,QAAQ,YAAY,QAAQ,gBAAgB,IAAI,YAAY,IAAI,GAEvF,MAAM,IAAI,MAAM,QAAQ,YAAY,KAAK,0CAA0C;EAErF,IAAI,CAAC,OAAO,OAAO,QAAQ,QAAQ,OAAO,YAAY,IAAI,GAExD,MAAM,IAAI,MAAM,2BAA2B,YAAY,MAAM;EAE/D,gBAAgB,IAAI,YAAY,IAAI;CACtC;CAEA,MAAM,QAAQ,OAAO,OAAO,QAAQ,QAAQ,KAAK;CAEjD,MAAM,gBAAgB,MAAM,KAAK,SAC/B,KAAK,kBAAkB,IAAI,KAC3B,CAAC,KAAK,mBACN;EAAC;EAAc;EAAsB;CAAa,CAAC,CAAC,SAAS,KAAK,YAAY,IAC1E,KAAK,SAAS,KAAK,UAAU,IAAI,IACjC,IACN;CAEA,MAAM,UAAU,cAAc,MAAM,MAAM,UAAU,SAAS,MAAM,MAAM,IACrE,QAAQ,KAAK,GAAG,aAAa,IAC7B,QAAQ;CAEZ,OAAO,OAAO,OAAO;EACnB,GAAG;EACH,SAAS,eAAe,SAAS,QAAQ,OAAO;EAChD,QAAQ,YAAY,QAAQ,QAAQ,MAAM;EAC1C,iBAAiB,OAAO,OAAO,EAAE,GAAG,QAAQ,OAAO,CAAC;EACpD,cACE,QAAQ,iBAAiB,KAAA,IACrB,KAAA,IACA,OAAO,OAAO;GACZ,GAAG,QAAQ;GACX,kBAAkB,OAAO,OAAO,CAAC,GAAI,QAAQ,aAAa,oBAAoB,CAAC,CAAE,CAAC;EACpF,CAAC;EACP,IAAIA,OAAE,WAAW,OAAO,CAAC,CAAC,EAAE;EAC5B,UAAU,QAAQ,aAAa,KAAA,IAAY,KAAA,IAAY,OAAO,OAAO,EAAE,GAAG,QAAQ,SAAS,CAAC;EAC5F,YACE,QAAQ,eAAe,KAAA,IAAY,KAAA,IAAY,OAAO,OAAO,EAAE,GAAG,QAAQ,WAAW,CAAC;EACxF,qBACE,QAAQ,wBAAwB,KAAA,IAC5B,KAAA,IACA,OAAO,OACL,QAAQ,oBAAoB,KAAK,gBAAgB,OAAO,OAAO,EAAE,GAAG,YAAY,CAAC,CAAC,CACpF;EACN,gBACE,QAAQ,mBAAmB,KAAA,IACvB,KAAA,IACA,OAAO,OAAO,EAAE,GAAG,QAAQ,eAAe,CAAC;CACnD,CAAC;AACH;AAQA,SAAgB,UACd,YACA,OACA;CACA,OAAO,OAAO,OAAO;EAAE;EAAY;CAAM,CAAC;AAC5C"}

package/dist/{AgentRuntime-BfP14534.d.mts → AgentRuntime-CHDyRbSf.d.mts}

@@ -3,19 +3,19 @@ import { i as SubagentBudgetReservation, l as SubagentGrant, u as SubagentParent
 import { i as UpdateError, n as Emitter } from "./AgentUpdates-DksV4D0A.mjs";
 import { c as RunUsageReport, s as RunTotals } from "./Usage-CzZJ6A2n.mjs";
 import { u as RunEvent } from "./RunEvent-C5jVQZ6K.mjs";
-import { n as ThreadHistoryError, t as ThreadHistory } from "./ThreadHistory-ByxS8HU1.mjs";
+import { n as ThreadHistoryError, t as ThreadHistory } from "./ThreadHistory-KPPBJLJb.mjs";
 import { n as CurrentToolCatalog } from "./ToolExposure-DFQKf9ET.mjs";
 import { s as ToolBroker } from "./ToolBroker-P5t4ZN78.mjs";
 import { c as AgentOutputError, f as AgentToolAuthorizationCheckError, g as ModelProtocolError, h as ContextOverflowError, l as AgentPersistenceCapacityError, m as ContextBudgetError, n as AgentApprovalPending, o as AgentInputError, p as AgentToolAuthorizationDenied, t as AgentApprovalDenied, u as AgentPolicyError } from "./AgentError-CBH7_MjG.mjs";
 import { t as AgentPolicy } from "./AgentPolicy-B4lbCU2T.mjs";
-import { A as ToolUnion, C as OutputSchema, D as RunDispositionFailure, E as RunDispositionDeclaration, N as UpdatesSchema, O as RunDispositionSchema, S as Output, _ as InstructionSource, a as CompletionFromToolDeclaration, c as Definition, d as EncodedInput, f as Failure, m as InputPromptSource, n as Any, r as AnyDefinition, s as CompletionToolDeclaration, t as Agent_d_exports, w as Requirements } from "./Agent-9aBoIi74.mjs";
+import { A as ToolUnion, C as OutputSchema, D as RunDispositionFailure, E as RunDispositionDeclaration, N as UpdatesSchema, O as RunDispositionSchema, S as Output, _ as InstructionSource, a as CompletionFromToolDeclaration, c as Definition, d as EncodedInput, f as Failure, m as InputPromptSource, n as Any, r as AnyDefinition, s as CompletionToolDeclaration, t as Agent_d_exports, w as Requirements } from "./Agent-B39jRnFv.mjs";
 import { a as WorkerBudgetScope } from "./Worker-CHRaIsWu.mjs";
 import { a as ContextWindow } from "./ContextWindow-Cvv8N9Xy.mjs";
 import { n as CompactionError } from "./ContextCompactor-Bz91grmO.mjs";
 import { t as DurableStep } from "./DurableStep-DXGn7KQ4.mjs";
-import { B as RunSubagentChildIdentity, H as RunSubagentEstablishRequest, M as RunOptions, S as RunContextPreparationError, W as RunSubagentJoinRequest, i as ChildEstablishStatus, l as ModelUsageAccounting, t as AgentUpdateAcceptance, x as RunContextPreparation } from "./RunOptions-D8zxFIrZ.mjs";
-import { t as MessagingHost } from "./MessagingHost-B8oKM7AC.mjs";
-import { o as SubagentHost } from "./SubagentHost-B6w2m-SI.mjs";
+import { B as RunSubagentChildIdentity, H as RunSubagentEstablishRequest, M as RunOptions, S as RunContextPreparationError, W as RunSubagentJoinRequest, i as ChildEstablishStatus, l as ModelUsageAccounting, t as AgentUpdateAcceptance, x as RunContextPreparation } from "./RunOptions-Be77lKVZ.mjs";
+import { t as MessagingHost } from "./MessagingHost-C6SOAcoG.mjs";
+import { o as SubagentHost } from "./SubagentHost-D1xBgn9g.mjs";
 import { t as RunEventSink } from "./RunEventSink-shh6Qf9E.mjs";
 import * as Tool$1 from "effect/ai/Tool";
 import * as Toolkit$1 from "effect/ai/Toolkit";
@@ -49,7 +49,7 @@ declare const ToolSpanTelemetry_base: Context.ServiceClass<ToolSpanTelemetry, "@
  * decorating, or locally providing a Tracer implementation.
  */
 declare class ToolSpanTelemetry extends ToolSpanTelemetry_base {
-  static readonly layer: Layer.Layer<ToolSpanTelemetry>;
+  static readonly make: Effect.Effect<ToolSpanTelemetryService>;
 }
 //#endregion
 //#region src/engine/internal/agent-runtime.d.ts
@@ -122,16 +122,16 @@ declare const decodeFinalOutput: <AgentValue extends Any>(agent: AgentValue, tex
 }, AgentOutputError, OutputSchema<AgentValue>["DecodingServices"]>;
 declare const projectCompletionOutput: <AgentValue extends Any>(agent: AgentValue, declaration: CompletionToolDeclaration<unknown, unknown, unknown>, parameters: unknown, result: unknown) => Effect.Effect<{
   encoded: Schema.Json;
-  decoded: unknown;
-}, AgentOutputError | ModelProtocolError, unknown>;
+  decoded: AgentValue["definition"]["output"]["Type"];
+}, AgentOutputError | ModelProtocolError, AgentValue["definition"]["output"]["DecodingServices"] | AgentValue["definition"]["output"]["EncodingServices"] | AgentCompletionProjectionRequirements<AgentValue>>;
 /** Reconstruct optional action completion identically for live execution and canonical recovery. */
 declare const projectCompletionFromToolOutput: <AgentValue extends Any>(agent: AgentValue, declaration: CompletionFromToolDeclaration<unknown, unknown, unknown>, parameters: unknown, result: unknown) => Effect.Effect<Option.None<{
   encoded: Schema.Json;
-  decoded: unknown;
+  decoded: AgentValue["definition"]["output"]["Type"];
 }> | Option.Some<{
   encoded: Schema.Json;
-  decoded: unknown;
-}>, AgentOutputError | ModelProtocolError, unknown>;
+  decoded: AgentValue["definition"]["output"]["Type"];
+}>, AgentOutputError | ModelProtocolError, AgentValue["definition"]["output"]["DecodingServices"] | AgentValue["definition"]["output"]["EncodingServices"] | AgentCompletionProjectionRequirements<AgentValue>>;
 declare function encodeRunDisposition<AgentValue extends Any>(agent: AgentValue, output: Output<AgentValue>): Effect.Effect<Schema.Json | undefined, RunDispositionFailure<AgentValue>, RunDispositionSchema<AgentValue>["EncodingServices"]>;
 /**
  * Scoped detached execution whose observers cannot backpressure Run
@@ -359,4 +359,4 @@ declare namespace AgentRuntime_d_exports {
 }
 //#endregion
 export { runUnknown as A, decodeFinalOutput as C, projectCompletionOutput as D, projectCompletionFromToolOutput as E, streamWithUsageAccountingUnknown as F, withTerminalDefectEvent as I, startUnknown as M, stream as N, renderInputPrompt as O, streamUnknown as P, ToolCallWaiting as S, executeWithUsageAccountingUnknown as T, SubagentDurability as _, AgentResultSchema as a, SubagentDurabilityError as b, AgentSpawner as c, DetachedRun as d, EngineProvidedToolServices as f, SpawnedChildRun as g, SpawnRunOptions as h, AgentResult as i, start as j, run as k, AgentSpawnerParent as l, SpawnDelegation as m, AgentChildPending as n, AgentRuntimeFailure as o, RuntimeBinding as p, AgentCompletionProjectionRequirements as r, AgentRuntimeRequirements as s, AgentRuntime_d_exports as t, AgentSpawnerService as u, SubagentDurabilityDurable as v, encodeRunDisposition as w, SubagentDurabilityService as x, SubagentDurabilityEphemeral as y };
-//# sourceMappingURL=AgentRuntime-BfP14534.d.mts.map
+//# sourceMappingURL=AgentRuntime-CHDyRbSf.d.mts.map