effect-agent 0.1.0-beta.96 → 0.1.0-beta.98

package/dist/{DurableFailpoint-DQJet828.d.mts → DurableFailpoint-mx3-nsxU.d.mts}

@@ -16,10 +16,10 @@ declare namespace DurableFailpoint_d_exports {
  * suspension, child abort propagation, the atomic join batch, and both reservation-release
  * transitions.
  */
-declare const DurableRuntimeFailpointLocation: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "run:before-duration-append", "run:after-duration-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
+declare const DurableRuntimeFailpointLocation: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "run:before-duration-append", "run:after-duration-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "tools:before-unavailable-append", "tools:after-unavailable-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
 type DurableRuntimeFailpointLocation = typeof DurableRuntimeFailpointLocation.Type;
 declare const DurableRuntimeFailpointError_base: Schema.Class<DurableRuntimeFailpointError, Schema.TaggedStruct<"DurableRuntimeFailpointError", {
-  readonly location: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "run:before-duration-append", "run:after-duration-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
+  readonly location: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "run:before-duration-append", "run:after-duration-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "tools:before-unavailable-append", "tools:after-unavailable-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
 }>, import("effect/Cause").YieldableError>;
 /** Injected coordinator fault. Reaching the caller means the preceding durable step committed. */
 declare class DurableRuntimeFailpointError extends DurableRuntimeFailpointError_base {}
@@ -38,4 +38,4 @@ declare class DurableRuntimeFailpoint extends DurableRuntimeFailpoint_base {
 }
 //#endregion
 export { DurableRuntimeFailpointLocation as a, DurableRuntimeFailpointHandler as i, DurableRuntimeFailpoint as n, DurableRuntimeFailpointError as r, DurableFailpoint_d_exports as t };
-//# sourceMappingURL=DurableFailpoint-DQJet828.d.mts.map
+//# sourceMappingURL=DurableFailpoint-mx3-nsxU.d.mts.map

package/dist/{EventSource-tCO_dAff.d.mts → EventSource-BZ73J0s5.d.mts}

@@ -1,5 +1,5 @@
-import { O as PersistedJson } from "./Records-CMByd1eD.mjs";
-import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, t as AcceptedEvent } from "./Subscription-CrTIQKZR.mjs";
+import { O as PersistedJson } from "./Records-BIiRLqlz.mjs";
+import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, t as AcceptedEvent } from "./Subscription-BCQ3L9Zp.mjs";
 import { Context, Effect, Schema, Scope } from "effect";
 declare namespace EventSource_d_exports {
   export { EventSource, EventSources, NormalizedEvent, makeEventSource };
@@ -48,4 +48,4 @@ declare const makeEventSource: <Event extends Schema.Top, Parameters extends Sch
 }) => Effect.Effect<EventSource, never, Exclude<R, Scope.Scope> | Exclude<Event["DecodingServices"], Scope.Scope> | Exclude<Event["EncodingServices"], Scope.Scope> | Exclude<Parameters["DecodingServices"], Scope.Scope> | Exclude<Parameters["EncodingServices"], Scope.Scope>>;
 //#endregion
 export { makeEventSource as a, NormalizedEvent as i, EventSource_d_exports as n, EventSources as r, EventSource as t };
-//# sourceMappingURL=EventSource-tCO_dAff.d.mts.map
+//# sourceMappingURL=EventSource-BZ73J0s5.d.mts.map

package/dist/{PreparedInputAdmission-CFSddiT8.d.mts → PreparedInputAdmission-BkeI-Xvr.d.mts}

@@ -1,7 +1,7 @@
 import { a as Receipt } from "./Receipt-BAHyigAF.mjs";
-import { fn as SubmissionStatus } from "./Records-CMByd1eD.mjs";
-import { H as ScheduledInputRefused, V as ScheduledInputFailure, j as ScheduleStorageError } from "./Schedule-BxCfnYr0.mjs";
-import { a as PreparedInput } from "./Subscription-CrTIQKZR.mjs";
+import { mn as SubmissionStatus } from "./Records-BIiRLqlz.mjs";
+import { H as ScheduledInputRefused, V as ScheduledInputFailure, j as ScheduleStorageError } from "./Schedule-BNFlluAl.mjs";
+import { a as PreparedInput } from "./Subscription-BCQ3L9Zp.mjs";
 import { Context, Effect } from "effect";
 declare namespace PreparedInputAdmission_d_exports {
   export { PreparedInputAdmission, admitPreparedInput };
@@ -35,4 +35,4 @@ declare const admitPreparedInput: <R>(submit: Effect.Effect<Receipt, ScheduledIn
 }, ScheduleStorageError, R>;
 //#endregion
 export { PreparedInputAdmission_d_exports as n, admitPreparedInput as r, PreparedInputAdmission as t };
-//# sourceMappingURL=PreparedInputAdmission-CFSddiT8.d.mts.map
+//# sourceMappingURL=PreparedInputAdmission-BkeI-Xvr.d.mts.map

package/dist/{Records-CMByd1eD.d.mts → Records-BIiRLqlz.d.mts}

@@ -12,14 +12,14 @@ import { t as AgentPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
 import { T as RunDispositionDeclaration, _ as InstructionSource, c as Definition, m as InputPromptSource, n as Any, r as AnyDefinition, v as ModelServices } from "./Agent-CM6JubNX.mjs";
 import { t as RunPolicyUsage } from "./RunPolicyUsage-ClZxyR46.mjs";
 import { a as WorkerError } from "./Worker--j87JI__.mjs";
-import { G as RunToolAuthorization, O as RunCostEstimator, h as RunApprovalHook, x as RunContextPreparation } from "./RunOptions-Clj8cLsp.mjs";
+import { G as RunToolAuthorization, O as RunCostEstimator, h as RunApprovalHook, x as RunContextPreparation } from "./RunOptions-Bruk54SE.mjs";
 import { _ as MessagingError, f as InputMessage, t as MessagingHost } from "./MessagingHost-gAxs5gme.mjs";
 import "./Messaging-QMYhp297.mjs";
 import { c as WorkerReportPreparationFailure, i as SubagentHost, l as WorkerReporting } from "./SubagentHost-DaFMZnVR.mjs";
-import { p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements } from "./AgentRuntime-B64362Id.mjs";
-import { n as DurableRuntimeFailpoint, r as DurableRuntimeFailpointError } from "./DurableFailpoint-DQJet828.mjs";
+import { p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements } from "./AgentRuntime-BMzrJos6.mjs";
+import { n as DurableRuntimeFailpoint, r as DurableRuntimeFailpointError } from "./DurableFailpoint-mx3-nsxU.mjs";
 import { o as OperationDenied } from "./OperationAuthorizer-TzcQtpX5.mjs";
-import { s as ToolReconciler } from "./ToolReconciler-DQVaJfpE.mjs";
+import { s as ToolReconciler } from "./ToolReconciler-BmVRAHKs.mjs";
 import { t as WakeScheduler } from "./WakeScheduler-EjUF-GhC.mjs";
 import { Prompt, Tool } from "effect/unstable/ai";
 import { Context, Crypto, DateTime, Duration, Effect, Layer, Option, Schema, Scope, Stream } from "effect";
@@ -44,12 +44,12 @@ type OwnershipToken = typeof OwnershipToken.Type;
  *   host Run's outcome.
  * - `suspended` — durably waiting for explicit approval decisions; the ownership period has
  *   ended and the lane consumes no worker permit while the obligation stays owed.
- * - `unknown` — at least one ordinary Tool Call has a durable Unknown Outcome; the lane is
- *   blocked until an authorized resolution covers every open call or a durable abort intent
- *   authorizes cleanup and aborted settlement without Tool replay (DUR-012/DUR-017).
+ * - `unknown` — at least one Tool Call has a durable Unknown Outcome; this Submission is
+ *   parked until an authorized resolution covers every open call or a durable abort intent
+ *   authorizes cleanup without Tool replay. Later eligible input may run (DUR-012/DUR-017).
  *
- * `claim` never grants a `joining`, `joined`, or `suspended` head. An `unknown` head is
- * claimable only with a durable abort intent, under the ordinary lease and fencing rules.
+ * `claim` never grants or bypasses a `joining`, `joined`, or `suspended` head. It skips unknown
+ * work without an abort intent. Any live ownership in the Thread prevents another claim.
  */
 declare const SubmissionState: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
 type SubmissionState = typeof SubmissionState.Type;
@@ -773,7 +773,7 @@ declare const MarkUnknownRequest_base: Schema.Class<MarkUnknownRequest, Schema.S
 }>, {}>;
 /**
  * Durable Unknown marking for one Submission's open ordinary Tool Calls (DUR-009): state →
- * `unknown`, the lane blocks, ownership-free (recovery may mark without a claim). Idempotent.
+ * `unknown`, parking that Submission without changing ownership or the Thread epoch. Idempotent.
  */
 declare class MarkUnknownRequest extends MarkUnknownRequest_base {}
 declare const ResolutionCompletedWithResult_base: Schema.Class<ResolutionCompletedWithResult, Schema.TaggedStruct<"CompletedWithResult", {
@@ -1020,10 +1020,10 @@ declare const SubmissionLedger_base: Context.ServiceClass<SubmissionLedger, "@ef
  *   Marking an already-ready (or later-state) Submission is a no-op.
  * - `lookup` — read one Submission by identity or scoped idempotency key; strongly consistent
  *   with prior ledger writes.
- * - `claim` — FIFO-head claim rule: claims ONLY the lowest unsettled `queueSequence` of the
- *   requested Thread lane (DUR-004/DUR-005), regardless of that head's nonterminal state,
- *   and returns `Option.none` when the lane has no unsettled work or the head's lease is still
- *   live under another owner. A successful claim atomically bumps the Thread's producer
+ * - `claim` — claims the lowest unsettled `queueSequence` after skipping only unknown rows
+ *   without abort intent. Approval, joining and child-wait barriers remain ordered. Returns
+ *   `Option.none` when no eligible work exists or ANY lease in the Thread is live, including
+ *   a lease belonging to the same producer. A successful claim atomically bumps the Thread's producer
  *   epoch — fencing every stale Attempt out of canonical appends (DUR-006) — mints a fresh
  *   `attemptId` and `ownershipToken`, and starts the ownership lease (D5: adapters default to
  *   `DEFAULT_OWNERSHIP_LEASE_DURATION`, configurable). An expired lease makes the head
@@ -1106,8 +1106,9 @@ declare const SubmissionLedger_base: Context.ServiceClass<SubmissionLedger, "@ef
  *   with `ChildReservationConflict`. "A crash before release leaves budget unavailable until
  *   repair, never available twice" (spec §12).
  * - `markUnknown` — idempotent, ownership-free (canonical evidence authorizes it): state →
- *   `unknown`, the lane blocks and stops consuming worker permits while the accepted settlement
- *   obligation stays visible (DUR-009/DUR-017). Fails with `SettlementConflict` once settled.
+ *   `unknown`, parking the Submission while its accepted settlement obligation stays visible.
+ *   Existing ownership must release or expire before another claim (DUR-009/DUR-017).
+ *   Fails with `SettlementConflict` once settled.
  * - `recordUnknownResolution` — durable, idempotent per `(submissionId, toolCallId)`; a
  *   divergent re-resolution fails with `UnknownResolutionConflict`. Transitions
  *   `unknown → input-applied` once no open call remains, waking the lane. Fails with
@@ -1167,8 +1168,8 @@ declare const DeclaredPendingBatchEvidence_base: Schema.Class<DeclaredPendingBat
 }>, {}>;
 /**
  * A committed tool-declaring response with ZERO prepared and ZERO settled records for its Turn:
- * the provably-safe durability §15 window — no prepared records means no handler ran, so the
- * declared batch resumes without model re-invocation and without Unknown.
+ * the durability §15 batch-resume window. Mutation preparation has not committed; readonly
+ * handlers may already have run. The worker checks each unfinished operation before execution.
  */
 declare class DeclaredPendingBatchEvidence extends DeclaredPendingBatchEvidence_base {}
 declare const PendingApprovalEvidence_base: Schema.Class<PendingApprovalEvidence, Schema.Struct<{
@@ -1337,7 +1338,7 @@ declare const ResumePendingToolBatch_base: Schema.Class<ResumePendingToolBatch,
   readonly turn: Schema.Int;
 }>, {}>;
 /** A committed tool-declaring response has zero prepared and zero settled records: a worker
- * resumes the declared batch — no model re-invocation, no Unknown (durability §15). S2 also
+ * checks unfinished contracts and resumes the declared batch without model re-invocation. S2 also
  * routes an open delegation call WITHOUT establishment evidence here (spec §13 row 1): the
  * declared batch re-executes and the idempotent establishment converges on one child. */
 declare class ResumePendingToolBatch extends ResumePendingToolBatch_base {}
@@ -1356,14 +1357,14 @@ declare class ResumeSuspended extends ResumeSuspended_base {}
 declare const AwaitUnknownResolution_base: Schema.Class<AwaitUnknownResolution, Schema.TaggedStruct<"AwaitUnknownResolution", {
   readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
 }>, {}>;
-/** Unknown Outcomes lack covering resolutions: the lane stays blocked awaiting the authorized
+/** Unknown Outcomes lack covering resolutions: this Submission stays parked awaiting the authorized
  * DUR-017 resolution path; the obligation stays visible, nothing replays. */
 declare class AwaitUnknownResolution extends AwaitUnknownResolution_base {}
 declare const ApplyUnknownResolutions_base: Schema.Class<ApplyUnknownResolutions, Schema.TaggedStruct<"ApplyUnknownResolutions", {
   readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
 }>, {}>;
-/** Durable resolution intents cover every open call: apply them canonically
- * (`ToolCallResolved` + `ToolCallSettled` for recovered results) and reopen the lane. */
+/** Durable resolution intents cover every open call: wake the original Submission when its
+ * required retry contract is supported. Canonical outcomes are applied by the next claim. */
 declare class ApplyUnknownResolutions extends ApplyUnknownResolutions_base {}
 declare const RevertJoining_base: Schema.Class<RevertJoining, Schema.TaggedStruct<"RevertJoining", {
   readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
@@ -1540,8 +1541,8 @@ type RecoveryDecision = typeof RecoveryDecision.Type;
  *    ApplyJoinAccounting → CompleteChildAdmission → RepairSubagentStartLink →
  *    AwaitChildAdmissionResolution → ResumePendingToolBatch (idempotent handler re-entry) →
  *    EnsureWaitingForChild → ResumeWaitingParent → ReleaseOrphanChildReservation.
- * 10. declared-but-unprepared tool batch → ResumePendingToolBatch — no handler ran (no prepared
- *     records), so the batch resumes with no model re-invocation and no Unknown (§15).
+ * 10. declared-but-unprepared tool batch → ResumePendingToolBatch — the worker checks original
+ *     operation contracts; missing preparation proves no mutation dispatch, not readonly nonexecution (§15).
  * 11. `admitted` → a parent-linked Submission whose Thread lacks the canonical lineage
  *     record defers (AwaitParentEstablishment: the parent's idempotent establishment
  *     completes it); otherwise
@@ -1580,49 +1581,17 @@ declare const BindingUnavailable_base: Schema.Class<BindingUnavailable, Schema.T
   readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
   readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/**
- * No Agent Binding is registered for the requested stable identity. Recovery
- * fails closed: it never substitutes the latest Binding or runs different
- * code.
- */
+/** No unique current executable is registered for the stable Agent identity. */
 declare class BindingUnavailable extends BindingUnavailable_base {}
-declare const BindingDigestMismatch_base: Schema.Class<BindingDigestMismatch, Schema.TaggedStruct<"BindingDigestMismatch", {
-  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
-  readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/**
- * A Binding is registered for the identity but neither the exact admission fingerprints
- * nor its declared replay contract support the retained pending operations. Refusal leaves
- * the original Submission pending until compatible code is available.
- */
-declare class BindingDigestMismatch extends BindingDigestMismatch_base {}
-/** The typed refusal family of durable Binding resolution (spec §11, SUB-032). */
-type DurableBindingFailure = BindingUnavailable | BindingDigestMismatch;
-/** Byte-for-byte equality of two stored definition digest triples (SUB-023). */
+type DurableBindingFailure = BindingUnavailable;
+/** Exact immutable admission, lineage and delivery evidence; never an executable-code gate. */
 declare const definitionDigestsEqual: (left: DefinitionDigests, right: DefinitionDigests) => boolean;
-/**
- * Host-owned semantic versions, independent of deployment and tool inventory. Change a version
- * when the meaning of an operation, its durable Step names or external idempotency keys changes.
- * Codecs and execution class are included automatically; JSON Schema alone cannot prove semantics.
- */
+/** Change an operation version when its meaning, durable Steps or idempotency keys change. */
 interface ReplayVersions {
-  readonly agent: PersistedJson;
   readonly tools: Readonly<Record<string, PersistedJson>>;
 }
-declare const BindingManifest_base: Schema.Class<BindingManifest, Schema.Struct<{
-  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
-  readonly definitions: typeof DefinitionDigestInput;
-  readonly replay: typeof ReplayContract;
-}>, {}>;
-/**
- * Data exported from a definition, never an old executable Binding. A host may supply an audited
- * manifest from the original release for work admitted before replay contracts were retained.
- * Its original declarations must hash to that admission; a bare old digest is not a manifest.
- */
-declare class BindingManifest extends BindingManifest_base {}
-declare const makeBindingManifest: (definition: Definition<Schema.Top, Schema.Top, unknown, import("effect/unstable/ai/Toolkit").Any, RunDispositionDeclaration<never, Schema.Top> | undefined, unknown, Schema.Top | undefined>, definitions: DefinitionDigestInput, versions: ReplayVersions) => Effect.Effect<BindingManifest, DigestError, Crypto.Crypto>;
-/** Resolve executable code only. Admission, delivery, lineage and receipt comparisons stay exact. */
-declare const bindingSupports: (binding: Pick<ResolvedBinding, "digests" | "retainedManifests">, digests: DefinitionDigests, requiredTools?: ReadonlyArray<string>) => boolean;
+/** Compile current metadata without acquiring executable services. */
+declare const compileBindingContracts: (definition: Definition<Schema.Top, Schema.Top, unknown, import("effect/unstable/ai/Toolkit").Any, RunDispositionDeclaration<never, Schema.Top> | undefined, unknown, Schema.Top | undefined>, definitions: DefinitionDigestInput, versions?: ReplayVersions | undefined) => Effect.Effect<Pick<ResolvedBinding, "digests">, DigestError, Crypto.Crypto>;
 type ExecutableDefinition = AnyDefinition & {
   readonly instructions: InstructionSource<never, unknown, unknown>;
   readonly inputPrompt?: InputPromptSource<never, unknown, unknown> | undefined;
@@ -1653,11 +1622,6 @@ type ReportRequirements<Reports> = Reports extends ReadonlyArray<WorkerReporting
 /** One exact executable registration used by durable claim-time resolution. */
 interface ResolvedBinding extends CapturedBinding {
   readonly digests: DefinitionDigests;
-  readonly manifest?: BindingManifest;
-  readonly retainedManifests?: ReadonlyArray<{
-    readonly digests: DefinitionDigests;
-    readonly replay: ReplayContract;
-  }>;
 }
 /** Trusted claim identity for resolving per-Attempt application services. Not model input. */
 interface AgentAttemptContext {
@@ -1687,10 +1651,9 @@ type AgentRegistration<A extends ExecutableAgentBinding = ExecutableAgentBinding
   readonly model: A["model"];
   readonly definitions: DefinitionDigestInput;
 }) & {
-  /** Opt into contract-checked deployment continuity. Omit to require an exact registration. */
+  /** Explicit operation versions let unchanged unfinished handlers survive toolbox changes. */
   readonly continuity?: {
     readonly versions: ReplayVersions;
-    readonly retainedManifests?: ReadonlyArray<BindingManifest>;
   };
   /**
    * Source-owned reports capture services outside attemptLayer and open a fresh Scope per
@@ -1721,7 +1684,7 @@ type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>>
 /** 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 {
-  export { AgentAttemptContext, AgentRegistration, BindingDigestMismatch, BindingManifest, BindingUnavailable, DurableBindingFailure, DurableWorkerBinding, ExecutableAgentBinding, ReplayVersions, ResolvedBinding, bindingSupports, compileRegistrations, definitionDigestsEqual, makeBindingManifest };
+  export { AgentAttemptContext, AgentRegistration, BindingUnavailable, DurableBindingFailure, DurableWorkerBinding, ExecutableAgentBinding, ReplayVersions, ResolvedBinding, compileBindingContracts, compileRegistrations, definitionDigestsEqual };
 }
 declare namespace Admin_d_exports {
   export { ExplainedEvidence, ExplainedSubmission, ExplainedUnknownCall, IntegrityCheck, IntegrityCheckName, IntegrityCheckStatus, IntegrityReport, ObligationBlockedOn, ObligationEntry, ObligationReport, ObligationSeverity, ObligationThresholds, RECOVERY_DECISION_MEANINGS, RecoveryDisposition, RecoveryExplanation, RetryCommand, RetryRefusalReason, RetryRefused, obligationSeverityOf, predictRecoveryDisposition, recoveryDecisionMeaning, renderRecoveryExplanation };
@@ -1752,10 +1715,10 @@ declare const ExplainedUnknownCall_base: Schema.Class<ExplainedUnknownCall, Sche
   readonly toolName: Schema.NonEmptyString;
   readonly reason: Schema.String;
   readonly recordedAt: Schema.DateTimeUtcFromString;
-  /** A durable `resolveUnknown` intent covers this call. */
+  /** A real canonical ToolCallSettled closes this call; an intent alone is not an outcome. */
   readonly resolved: Schema.Boolean;
 }>, {}>;
-/** One durable Unknown Outcome and whether a covering resolution intent exists (DUR-017). */
+/** One durable Unknown Outcome and whether its result is canonical (DUR-017). */
 declare class ExplainedUnknownCall extends ExplainedUnknownCall_base {}
 declare const ExplainedEvidence_base: Schema.Class<ExplainedEvidence, Schema.Struct<{
   readonly threadMaterialized: Schema.Boolean;
@@ -1764,6 +1727,8 @@ declare const ExplainedEvidence_base: Schema.Class<ExplainedEvidence, Schema.Str
   readonly recordedSettlementOutcome: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
   /** Prepared ordinary Tool Calls without a canonical outcome (DUR-009). */
   readonly openToolCalls: Schema.$Array<typeof OpenToolCallEvidence>;
+  /** Original prepared operation identities, arguments and recovery contracts; settled calls are excluded. */
+  readonly pendingOperations: Schema.withConstructorDefault<Schema.$Array<typeof ToolCallPrepared>>;
   /** Delegation Tool Calls with an open parent-side obligation. */
   readonly openDelegationCalls: Schema.$Array<typeof OpenDelegationCallEvidence>;
   /** Canonically requested approvals without a canonical decision. */
@@ -1906,8 +1871,8 @@ declare const RetryCommand_base: Schema.Class<RetryCommand, Schema.Struct<{
 /**
  * The mandatory-audit retry command (SEC-011): `author`/`reason` carry the same bounds as the
  * canonical abort command so every mutating administrative operation stays attributable. The
- * executed repair itself appends the deterministic `RepairAnnotated` audit record (DUR-013) —
- * retry adds no new canonical record type.
+ * operator and decision are logged. A repair with a claim also appends a best-effort
+ * `RepairAnnotated` attempt using that claim's epoch; state-only repairs do not append audits.
  */
 declare class RetryCommand extends RetryCommand_base {}
 /** Why a retry was refused without executing anything. */
@@ -1920,7 +1885,7 @@ declare const RetryRefused_base: Schema.Class<RetryRefused, Schema.TaggedStruct<
   readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 /**
- * Typed refusal of `retry` (plan §3): lanes blocked on `AwaitUnknownResolution` or
+ * Typed refusal of `retry` (plan §3): Submissions waiting on `AwaitUnknownResolution` or
  * `AwaitApprovalDecision` have their own authorized operations, and settled work is never
  * re-driven. The refusal names the classifier decision so the operator sees WHY.
  */
@@ -1980,7 +1945,7 @@ interface JournalMetadata {
   }>;
 }
 declare namespace RunJournal_d_exports {
-  export { JournalBoundary, RunJournalError, RunJournalProjection, RunJournalUsage, TurnCommitInput, approvalDecisionBatchId, childIdempotencyKeyFor, childThreadIdFor, compactionBatchId, compactionRecordId, markUnknownBatchId, modelResponseInterruptedBatchId, modelResponseInterruptedRecordId, modelResponseRecordId, projectRunJournal, projectRunJournalStream, promptFromCanonicalRecords, runCompletedRecordId, runDurationBatchId, runDurationRecordId, runIdForSubmission, runStartedBatchId, runStartedRecordId, subagentJoinBatchId, subagentJoinedRecordId, subagentLineageBatchId, subagentLineageRecordId, subagentRequestedBatchId, subagentRequestedRecordId, subagentStartedBatchId, subagentStartedRecordId, toolApprovalDecisionRecordId, toolApprovalRequestRecordId, toolCallPreparedRecordId, toolCallResolutionBatchId, toolCallResolvedRecordId, toolCallResultBatchId, toolCallSettledRecordId, toolCallUnknownRecordId, toolStepSettledBatchId, toolStepSettledRecordId, turnApprovalsBatchId, turnBatchId, turnCanonicalBatch, turnIdForRun, turnPreparedBatchId, turnResponseBatch, turnResponseBatchId, turnResultsBatch, turnResultsBatchId };
+  export { JournalBoundary, RunJournalError, RunJournalProjection, RunJournalUsage, TurnCommitInput, approvalDecisionBatchId, childIdempotencyKeyFor, childThreadIdFor, compactionBatchId, compactionRecordId, markUnknownBatchId, modelResponseInterruptedBatchId, modelResponseInterruptedRecordId, modelResponseRecordId, projectRunJournal, projectRunJournalStream, promptFromCanonicalRecords, runCompletedRecordId, runCompletionDigest, runDurationBatchId, runDurationRecordId, runIdForSubmission, runStartedBatchId, runStartedRecordId, subagentJoinBatchId, subagentJoinedRecordId, subagentLineageBatchId, subagentLineageRecordId, subagentRequestedBatchId, subagentRequestedRecordId, subagentStartedBatchId, subagentStartedRecordId, toolApprovalDecisionRecordId, toolApprovalRequestRecordId, toolCallPreparedRecordId, toolCallResolutionBatchId, toolCallResolvedRecordId, toolCallResultBatchId, toolCallSettledRecordId, toolCallUnknownRecordId, toolStepSettledBatchId, toolStepSettledRecordId, turnApprovalsBatchId, turnBatchId, turnCanonicalBatch, turnIdForRun, turnPreparedBatchId, turnResponseBatch, turnResponseBatchId, turnResultsBatch, turnResultsBatchId };
 }
 declare const RunJournalError_base: Schema.Class<RunJournalError, Schema.TaggedStruct<"RunJournalError", {
   readonly message: Schema.String;
@@ -2157,7 +2122,7 @@ interface RunJournalProjection {
   readonly policyUsage: RunPolicyUsage;
   /** Canonical projection for the requested Run; may end at its resumable Tool declaration. */
   readonly prompt: Prompt.Prompt;
-  /** Valid prior-Run history excluding the projected Run's records and orphan Tool batches. */
+  /** Prior-Run history with model-only unknown results closing incomplete application calls. */
   readonly historyBefore: Prompt.Prompt;
   /** Number of canonical Turns already committed for the projected Run. */
   readonly committedTurns: number;
@@ -2172,9 +2137,8 @@ interface RunJournalProjection {
 }
 /**
  * Pure projection: rebuild one Run's resume state from canonical records (DUR-015). Canonical
- * order is authoritative; the fold projects each complete `ModelResponseRecorded` Turn and the
- * owning Run's resumable incomplete Tool Turn, while excluding incomplete Tool batches from prior
- * Runs. It flushes each contiguous group of valid `ToolCallSettled` records into one Tool message,
+ * order is authoritative; the fold projects each `ModelResponseRecorded` Turn and the
+ * owning Run's resumable incomplete Tool Turn. It flushes each contiguous group of valid `ToolCallSettled` records into one Tool message,
  * exactly mirroring the per-Turn commit shape produced by `turnCanonicalBatch` (no-tool Turns) and
  * by the
  * `turnResponseBatch`/`turnResultsBatch` split (tool-declaring Turns). The Phase 5 audit tags
@@ -2183,8 +2147,10 @@ interface RunJournalProjection {
  *
  * An incomplete application Tool turn remains visible while projecting its owning Run so active
  * recovery can resume the declared batch. It is not a valid model-visible Turn boundary for a
- * later Run: the orphan assistant Tool declaration and any partial Tool results from that Turn
- * are excluded, while preceding instruction/user messages in the response record remain history.
+ * later Run until model-only unknown results close its missing calls. Those explanatory results
+ * are never canonical settlements or evidence for compaction, recovery or accounting. Real
+ * results replace them at the original declaration, including results appended after another Run.
+ * Prior user intent and assistant text remain visible; prior system instructions do not.
  */
 /** @internal Lightweight canonical boundaries collected without retaining record payloads. */
 interface JournalBoundary {
@@ -2216,6 +2182,7 @@ declare const projectRunJournal: (records: readonly CanonicalRecordEnvelope[], r
  */
 declare const promptFromCanonicalRecords: (records: readonly CanonicalRecordEnvelope[]) => Effect.Effect<Prompt.Prompt, RunJournalError, never>;
 interface TurnCommitInput {
+  readonly toolOperations?: ModelResponseRecorded["toolOperations"] | undefined;
   readonly toolParameterRejections?: ReadonlyArray<ToolParameterRejection> | undefined;
   readonly toolExposure?: Snapshot | undefined;
   readonly toolSelections?: ReadonlyMap<string, Selection> | undefined;
@@ -2252,6 +2219,8 @@ interface TurnCommitInput {
     readonly modelUsage?: ReadonlyArray<ModelCallUsage> | undefined;
   } | undefined;
 }
+/** Integrity of the original validated terminal values; never a current-code projection. */
+declare const runCompletionDigest: (completion: Pick<RunCompleted, "runId" | "output" | "runDisposition" | "finishReason" | "exhausted">) => Effect.Effect<string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">, DigestError, Crypto.Crypto>;
 /**
  * Pure per-Turn canonical batch builder (TurnCompleted seam fold, D6/D8): one
  * `ModelResponseRecorded` record plus one `ToolCallSettled` record per terminal Tool result, all
@@ -2281,7 +2250,7 @@ declare const turnResponseBatch: (input: TurnCommitInput) => Effect.Effect<Canon
  * model-visible atomically. Non-tool messages in `appended` are ignored; a Turn without any
  * terminal Tool result has no results batch and fails typed.
  */
-declare const turnResultsBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, RunJournalError, never>;
+declare const turnResultsBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, DigestError | RunJournalError, Crypto.Crypto>;
 declare namespace SubmissionStatus_d_exports {
   export { PendingSubmission, SettledSubmission, SubmissionStatus };
 }
@@ -2495,7 +2464,7 @@ declare const RecoveryReport_base: Schema.Class<RecoveryReport, Schema.Struct<{
   readonly decision: Schema.Union<readonly [typeof CompleteMaterialization, typeof RepairReadiness, typeof ApplyInput, typeof RepairInputMarker, typeof ResumeFromTurnBoundary, typeof AppendReservedSettlement, typeof FinalizeLedgerFromHistory, typeof SettleAborted, typeof MarkUnknown, typeof ResumePendingToolBatch, typeof AwaitApprovalDecision, typeof ResumeSuspended, typeof AwaitUnknownResolution, typeof ApplyUnknownResolutions, typeof RevertJoining, typeof RepairJoinMarker, typeof SettleJoinedWithHost, typeof AwaitHostSettlement, typeof CompleteChildAdmission, typeof AwaitChildAdmissionResolution, typeof RepairSubagentStartLink, typeof EnsureWaitingForChild, typeof AwaitChildSettlement, typeof ResumeWaitingParent, typeof ApplyJoinAccounting, typeof PropagateChildAbort, typeof ReleaseOrphanChildReservation, typeof AwaitParentEstablishment, typeof NoAction]>;
   /**
    * `repaired` = executed; `deferred` = a claiming worker must finish it; `none` = settled;
-   * `unknown` = the lane is durably blocked on an Unknown Outcome awaiting the authorized
+   * `unknown` = this Submission is parked on an Unknown Outcome awaiting the authorized
    * DUR-017 resolution path — the settlement obligation stays visible while no worker permit
    * is consumed (durability §16).
    */
@@ -2585,6 +2554,10 @@ declare const DurableApprovalResolver: Context.Reference<RunApprovalHook<never,
  */
 type DurableWorkerRequirements<AgentValue extends Any, InstructionRequirements = never> = Exclude<AgentRuntimeRequirements<AgentValue, never, InstructionRequirements>, ThreadHistory | RunContextPreparation> | AgentCompletionProjectionRequirements<AgentValue>;
 interface DurableRuntimeConfigOptions {
+  /**
+   * Deployment identity and the conservative operation version for direct execution without
+   * a registered binding. Reuse asserts unchanged handler, Step, and idempotency semantics.
+   */
   readonly deploymentId: DeploymentId;
   readonly producerId: ProducerId;
   /** `awaitSettlement` ledger re-check cadence when no wake arrives (default 500ms). */
@@ -2665,8 +2638,8 @@ declare const DurableAgentRuntime_base: Context.ServiceClass<DurableAgentRuntime
   readonly verify: (threadId: ThreadId) => Effect.Effect<IntegrityReport, DurableVerifyFailure>;
   /**
    * Safe re-drive of one Submission's recovery decision with mandatory author/reason audit
-   * (SEC-011): executes exactly the repair the classifier names and appends the
-   * deterministic `RepairAnnotated` record when it repairs (DUR-013). Typed `RetryRefused`
+   * (SEC-011): executes exactly the repair the classifier names; owned repair attempts
+   * append a best-effort `RepairAnnotated` with their actual claim epoch (DUR-013). Typed `RetryRefused`
    * for settled work and for lanes owned by the resolveUnknown/resolveApproval paths.
    */
   readonly retry: (command: RetryCommand) => Effect.Effect<RecoveryReport, DurableRetryFailure>;
@@ -2734,19 +2707,16 @@ declare const DurableAgentRuntime_base: Context.ServiceClass<DurableAgentRuntime
  *   the next model request, reattaches through the prompt-coverage rule after a crash, and the
  *   joined Submissions settle with the host outcome (DUR-002/DUR-016).
  * - `runWorker(agent)` — scan-seeded, wake-driven worker loop over every lane (WP4's host driver),
- *   reimplemented over a singleton identity-exact (digest-transparent) Binding resolution: a
- *   claimed head belonging to a different Agent never runs against this binding (SUB-023); a
- *   parent-linked head refused this way settles with the framework `ChildCompatibilityFailure`.
+ *   over a singleton current Binding: a claimed head belonging to a different Agent never
+ *   runs against this binding. Missing bindings leave accepted roots and children owed.
  * - `processThreadResolved(threadId)` / `runResolvedWorker` — the
- *   S2 multi-binding equivalents over registrations owned by the runtime Layer (spec §11, D7): every claimed
- *   head's stored `(agentId, agentDigests)` resolves to the exact registered Binding before any
- *   code runs; an unresolvable parent-linked child settles with the Schema-stable framework
- *   `ChildCompatibilityFailure` (no application code, the child never executes), and an
- *   unresolvable root surfaces the typed refusal after releasing the claim.
+ *   equivalents over registrations owned by the runtime Layer: each stable `agentId` selects
+ *   one current Binding. Unfinished operation contracts gate handler execution independently
+ *   of immutable admission evidence; missing bindings release the claim with a typed refusal.
  * - `runRecovery()` — classify every nonterminal Submission with the pure `classifyRecovery` and
- *   execute the repair decisions, appending a `RepairAnnotated` audit record per executed decision
+ *   execute repair decisions, annotating owned repair attempts with their granted epochs
  *   (DUR-013). Untouched ready input and model-resuming work are reported `deferred` for a
- *   worker claim; lanes blocked on
+ *   worker claim; Submissions parked on
  *   Unknown Outcomes are reported `unknown`. The S2 binding-free Subagent executors (admission
  *   completion, start-link repair, waiting restoration, wake replay, canonical join accounting,
  *   abort propagation, orphan reservation release) run here; the settlement join itself is
@@ -2797,7 +2767,7 @@ declare class DurableAgentRuntime extends DurableAgentRuntime_base {
   static readonly layer: Layer.Layer<DurableAgentRuntime, never, SubmissionLedger | ThreadStore | WakeScheduler | DurableRuntimeFailpoint | DurableRuntimeConfig | ToolReconciler | Crypto.Crypto>;
 }
 declare namespace Records_d_exports {
-  export { AbortRequested, AbortedSubmissionSettled, AgentUpdateEmitted, ApprovalDecision, BatchId, CURRENT_CANONICAL_SCHEMA_VERSION, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalRecordPayload, CanonicalSequence, CompactionCreated, CompletedSubmissionSettled, DefinitionDigestInput, DefinitionDigests, DeploymentId, Digest, FailedSubmissionSettled, MAX_PERSISTED_JSON_BYTES, MAX_PERSISTED_JSON_COLLECTION_LENGTH, MAX_PERSISTED_JSON_DEPTH, MAX_PERSISTED_JSON_NODES, ModelCompleted, ModelResponseInterrupted, ModelResponseRecorded, ObservationOffset, PeerMessagePrepared, PersistedJson, ProducerEpoch, ProducerId, RecordEnvelope, RecordId, RepairAnnotated, ReplayContract, RunCompleted, RunDurationExhausted, RunFailed, RunPolicyUsageReserved, RunStartedRecord, SettlementFailureDiagnostic, SettlementOutcome, SubagentJoined, SubagentLineageRecorded, SubagentRequested, SubagentStarted, SubmissionSettled, SubmissionSettledRecord, SubtreeBudgetReserved, ThreadCreated, ToolApprovalDecided, ToolApprovalRequested, ToolCallPrepared, ToolCallResolution, ToolCallResolved, ToolCallSettled, ToolCallUnknown, ToolStepSettled, UserInputRecorded, WorkerAdmission, WorkerInputCompleted, WorkerInputRequested, WorkerOrigin, WorkerOriginRecorded, WorkerReportPrepared, WorkerReportRefused, WorkerReportingIntent };
+  export { AbortRequested, AbortedSubmissionSettled, AgentUpdateEmitted, ApprovalDecision, BatchId, CURRENT_CANONICAL_SCHEMA_VERSION, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalRecordPayload, CanonicalSequence, CompactionCreated, CompletedSubmissionSettled, DefinitionDigestInput, DefinitionDigests, DeploymentId, Digest, FailedSubmissionSettled, MAX_PERSISTED_JSON_BYTES, MAX_PERSISTED_JSON_COLLECTION_LENGTH, MAX_PERSISTED_JSON_DEPTH, MAX_PERSISTED_JSON_NODES, ModelCompleted, ModelResponseInterrupted, ModelResponseRecorded, ObservationOffset, PeerMessagePrepared, PersistedJson, ProducerEpoch, ProducerId, RecordEnvelope, RecordId, RepairAnnotated, ReplayContract, RunCompleted, RunDurationExhausted, RunFailed, RunPolicyUsageReserved, RunStartedRecord, SettlementFailureDiagnostic, SettlementOutcome, SubagentJoined, SubagentLineageRecorded, SubagentRequested, SubagentStarted, SubmissionSettled, SubmissionSettledRecord, SubtreeBudgetReserved, ThreadCreated, ToolApprovalDecided, ToolApprovalRequested, ToolCallPrepared, ToolCallResolution, ToolCallResolved, ToolCallSettled, ToolCallUnknown, ToolOperation, ToolStepSettled, ToolUnavailable, UserInputRecorded, WorkerAdmission, WorkerInputCompleted, WorkerInputRequested, WorkerOrigin, WorkerOriginRecorded, WorkerReportPrepared, WorkerReportRefused, WorkerReportingIntent };
 }
 /** Stable identity of one canonical record. */
 declare const RecordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
@@ -2858,9 +2828,11 @@ declare const DefinitionDigestInput_base: Schema.Class<DefinitionDigestInput, Sc
 declare class DefinitionDigestInput extends DefinitionDigestInput_base {}
 declare const ReplayContract_base: Schema.Class<ReplayContract, Schema.Struct<{
   readonly agent: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  /** Retained for reading earlier admissions; never selects executable code. */
+  readonly agentBehavior: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
   readonly tools: Schema.$Record<Schema.String, Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
 }>, {}>;
-/** The contracts a retained Run may decode or execute, independent of its deployment. */
+/** Admission-time operation fingerprints. Agent fingerprints remain immutable evidence only. */
 declare class ReplayContract extends ReplayContract_base {}
 declare const DefinitionDigests_base: Schema.Class<DefinitionDigests, Schema.Struct<{
   readonly agent: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
@@ -2868,7 +2840,7 @@ declare const DefinitionDigests_base: Schema.Class<DefinitionDigests, Schema.Str
   readonly tools: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
   readonly replay: Schema.optionalKey<typeof ReplayContract>;
 }>, {}>;
-/** Digests identify admission exactly; replay contracts separately authorize continuation. */
+/** Digests identify admission exactly; only an unfinished operation needs replay compatibility. */
 declare class DefinitionDigests extends DefinitionDigests_base {}
 declare const ThreadCreated_base: Schema.Class<ThreadCreated, Schema.TaggedStruct<"ThreadCreated", {
   readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
@@ -2982,8 +2954,25 @@ declare const ToolCallSettled_base: Schema.Class<ToolCallSettled, Schema.TaggedS
   readonly budgetRejected: Schema.optionalKey<Schema.Literal<true>>;
 }>, {}>;
 declare class ToolCallSettled extends ToolCallSettled_base {}
+declare const ToolOperation_base: Schema.Class<ToolOperation, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly executionClass: Schema.Literals<readonly ["readonly", "idempotent", "uncertain"]>;
+  readonly executionKind: Schema.Literals<readonly ["ordinary", "delegation", "orchestration"]>;
+  readonly replay: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/** Compact execution evidence committed with a declaration, before any handler can start. */
+declare class ToolOperation extends ToolOperation_base {}
+declare const ToolUnavailable_base: Schema.Class<ToolUnavailable, Schema.TaggedStruct<"ToolUnavailable", {
+  readonly toolName: Schema.NonEmptyString;
+  readonly execution: Schema.Literals<readonly ["not-executed", "unavailable"]>;
+  readonly message: Schema.String;
+}>, {}>;
+/** A retired call's runtime result. Unavailable readonly work may already have been observed. */
+declare class ToolUnavailable extends ToolUnavailable_base {}
 declare const ModelResponseRecorded_base: Schema.Class<ModelResponseRecorded, Schema.Struct<{
   readonly _tag: Schema.tag<"ModelResponseRecorded">;
+  readonly toolOperations: Schema.optionalKey<Schema.$Array<typeof ToolOperation>>;
   readonly toolParameterRejections: Schema.optionalKey<Schema.$Array<Schema.Struct<{
     readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
     readonly parameters: Schema.Codec<Schema.Json, Schema.Json, never, never>;
@@ -3018,6 +3007,8 @@ declare const ToolCallPrepared_base: Schema.Class<ToolCallPrepared, Schema.Tagge
   readonly parametersDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
   /** Absent legacy evidence grants no delegation replay authority. */
   readonly executionKind: Schema.optionalKey<Schema.Literals<readonly ["ordinary", "delegation", "orchestration"]>>;
+  readonly executionClass: Schema.optionalKey<Schema.Literals<readonly ["readonly", "idempotent", "uncertain"]>>;
+  readonly replay: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
 }>, {}>;
 /**
  * One approved uncertain/idempotent ordinary Tool Call made durable BEFORE any handler starts
@@ -3153,6 +3144,7 @@ declare const RunCompleted_base: Schema.Class<RunCompleted, Schema.Struct<{
   readonly _tag: Schema.tag<"RunCompleted">;
   readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
   readonly output: Schema.declare<Schema.Json, Schema.Json>;
+  readonly resultDigest: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
   readonly runDisposition: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
   readonly finishReason: Schema.optionalKey<Schema.Literal<"budget-exhausted">>;
   readonly exhausted: Schema.optionalKey<Schema.Literals<readonly ["tokens", "tool-calls", "turns"]>>;
@@ -3642,5 +3634,5 @@ declare const CanonicalRecordEnvelope_base: Schema.Class<CanonicalRecordEnvelope
 declare class CanonicalRecordEnvelope extends CanonicalRecordEnvelope_base {}
 declare const CURRENT_CANONICAL_SCHEMA_VERSION: 1;
 //#endregion
-export { ToolCallPrepared as $, SubmissionLookupById as $a, ApprovalConflict as $i, toolCallUnknownRecordId as $n, digestDefinition as $r, ThreadMaterialization as $t, ProducerId as A, ParentLinkage as Aa, RepairReadiness as Ai, projectRunJournalStream as An, obligationSeverityOf as Ar, DurableSubmitOptions as At, RunStartedRecord as B, ResolutionNeverHappened as Ba, AbortCommand as Bi, subagentLineageBatchId as Bn, DurableBindingFailure as Br, AppendConflict as Bt, ModelCompleted as C, MarkJoinedRequest as Ca, PropagateChildAbort as Ci, compactionBatchId as Cn, ObligationThresholds as Cr, DurableProgressFailure as Ct, PeerMessagePrepared as D, OwnershipRenewal as Da, ReleaseOrphanChildReservation as Di, modelResponseInterruptedRecordId as Dn, RetryCommand as Dr, DurableRuntimeConfigOptions as Dt, ObservationOffset as E, OwnershipLost as Ea, Recovery_d_exports as Ei, modelResponseInterruptedBatchId as En, RecoveryExplanation as Er, DurableRuntimeConfig as Et, ReplayContract as F, RenewOwnershipRequest as Fa, ResumeWaitingParent as Fi, runIdForSubmission as Fn, AgentAttemptContext as Fr, childReservationIdFor as Ft, SubagentRequested as G, SettlementFinalization as Ga, AdmissionFence as Gi, subagentStartedRecordId as Gn, bindingSupports as Gr, LoadCheckpointRequest as Gt, SettlementOutcome as H, RevertJoiningRequest as Ha, AbortIntentRequest as Hi, subagentRequestedBatchId as Hn, ExecutableAgentBinding as Hr, CheckpointRejected as Ht, RunCompleted as I, ReservedChildBudget as Ia, RevertJoining as Ii, runStartedBatchId as In, AgentRegistration as Ir, recoveryRepairBatchId as It, SubmissionSettledRecord as J, SubmissionAdmissionFence as Ja, AdmissionNotAdmitted as Ji, toolCallPreparedRecordId as Jn, makeBindingManifest as Jr, SaveRecoveryCheckpointRequest as Jt, SubagentStarted as K, SettlementReservation as Ka, AdmissionGroup as Ki, toolApprovalDecisionRecordId as Kn, compileRegistrations as Kr, MAX_THREAD_EXPORT_RECORDS as Kt, RunDurationExhausted as L, ReservedSettlement as La, SettleAborted as Li, runStartedRecordId as Ln, BindingDigestMismatch as Lr, recoveryRepairRecordId as Lt, RecordId as M, RecoverySnapshotRequest as Ma, ResumeFromTurnBoundary as Mi, runCompletedRecordId as Mn, recoveryDecisionMeaning as Mr, DurableWorkerFailure as Mt, Records_d_exports as N, ReleaseChildBudgetRequest as Na, ResumePendingToolBatch as Ni, runDurationBatchId as Nn, renderRecoveryExplanation as Nr, DurableWorkerRequirements as Nt, PersistedJson as O, OwnershipSnapshot as Oa, RepairInputMarker as Oi, modelResponseRecordId as On, RetryRefusalReason as Or, DurableSubmitAgent as Ot, RepairAnnotated as P, ReleaseOwnershipRequest as Pa, ResumeSuspended as Pi, runDurationRecordId as Pn, AgentRegistration_d_exports as Pr, RecoveryReport as Pt, ToolApprovalRequested as Q, SubmissionLookup as Qa, AdmissionResult as Qi, toolCallSettledRecordId as Qn, digestCanonicalBatch as Qr, ThreadExportRequest as Qt, RunFailed as R, ResolutionAbortSubmission as Ra, SettleJoinedWithHost as Ri, subagentJoinBatchId as Rn, BindingManifest as Rr, threadCreatedBatchId as Rt, MAX_PERSISTED_JSON_NODES as S, MarkInputAppliedRequest as Sa, PendingApprovalEvidence as Si, childThreadIdFor as Sn, ObligationSeverity as Sr, DurableObserveOptions as St, ModelResponseRecorded as T, MarkUnknownRequest as Ta, RecoveryEvidence as Ti, markUnknownBatchId as Tn, RecoveryDisposition as Tr, DurableRetryFailure as Tt, SubagentJoined as U, Settlement as Ua, AdmissionAdmitted as Ui, subagentRequestedRecordId as Un, ReplayVersions as Ur, FenceRejected as Ut, SettlementFailureDiagnostic as V, ResolutionSafeToRetry as Va, AbortIntent as Vi, subagentLineageRecordId as Vn, DurableWorkerBinding as Vr, AppendResult as Vt, SubagentLineageRecorded as W, SettlementConflict as Wa, AdmissionConflict as Wi, subagentStartedBatchId as Wn, ResolvedBinding as Wr, FencedAppendRequest as Wt, ThreadCreated as X, SubmissionLedgerFailure as Xa, AdmissionRequest as Xi, toolCallResolvedRecordId as Xn, Digest_d_exports as Xr, ThreadCheckpoints as Xt, SubtreeBudgetReserved as Y, SubmissionLedger as Ya, AdmissionPolicyError as Yi, toolCallResolutionBatchId as Yn, DigestError as Yr, ThreadCheckpoint as Yt, ToolApprovalDecided as Z, SubmissionLedger_d_exports as Za, AdmissionResolution as Zi, toolCallResultBatchId as Zn, EMPTY_TAIL_DIGEST as Zr, ThreadExport as Zt, Digest as _, InputAppliedMarker as _a, FinalizeLedgerFromHistory as _i, RunJournalUsage as _n, submissionInputRecordId as _o, IntegrityCheckStatus as _r, DurableApprovalFailure as _t, BatchId as a, ChildAttachmentSnapshot as aa, ApplyUnknownResolutions as ai, ThreadStoreError as an, SuspensionReason as ao, turnIdForRun as ar, UserInputRecorded as at, MAX_PERSISTED_JSON_COLLECTION_LENGTH as b, LedgerCapabilities as ba, OpenDelegationCallEvidence as bi, approvalDecisionBatchId as bn, submissionSettlementRecordId as bo, ObligationEntry as br, DurableExplainFailure as bt, CanonicalRecord as c, ChildReservationConflict as ca, AwaitChildSettlement as ci, ThreadTail as cn, UnknownResolutionCommand as co, turnResponseBatchId as cr, WorkerInputRequested as ct, CanonicalSequence as d, ChildSettledNotification as da, AwaitUnknownResolution as di, SettledSubmission as dn, WaitingChild as do, Admin_d_exports as dr, WorkerReportPrepared as dt, ApprovalDecisionCommand as ea, digestDefinitions as ei, ThreadNotMaterialized as en, SubmissionLookupByKey as eo, toolStepSettledBatchId as er, ToolCallResolution as et, CompactionCreated as f, ChildSettledOutcome as fa, CompleteChildAdmission as fi, SubmissionStatus as fn, WaitingForChildSuspension as fo, ExplainedEvidence as fr, WorkerReportRefused as ft, DeploymentId as g, DEFAULT_OWNERSHIP_LEASE_DURATION as ga, EnsureWaitingForChild as gi, RunJournalProjection as gn, submissionInputBatchId as go, IntegrityCheckName as gr, DurableAgentRuntime_d_exports as gt, DefinitionDigests as h, ClaimRequest as ha, DelegationAdmissionEvidence as hi, RunJournalError as hn, submissionAbortRecordId as ho, IntegrityCheck as hr, DurableAgentRuntime as ht, ApprovalDecision as i, BeginChildBudgetReleaseRequest as ia, ApplyJoinAccounting as ii, ThreadStore as in, SuspensionOutcome as io, turnCanonicalBatch as ir, ToolStepSettled as it, RecordEnvelope as j, RecoverySnapshot as ja, RepairSubagentStartLink as ji, promptFromCanonicalRecords as jn, predictRecoveryDisposition as jr, DurableVerifyFailure as jt, ProducerEpoch as k, OwnershipToken as ka, RepairJoinMarker as ki, projectRunJournal as kn, RetryRefused as kr, DurableSubmitFailure as kt, CanonicalRecordEnvelope as l, ChildReservationId as la, AwaitHostSettlement as li, ThreadTailRequest as ln, UnknownResolutionConflict as lo, turnResultsBatch as lr, WorkerOrigin as lt, DefinitionDigestInput as m, ClaimJoiningRequest as ma, DeclaredPendingBatchEvidence as mi, JournalBoundary as mn, submissionAbortBatchId as mo, ExplainedUnknownCall as mr, DurableAbortFailure as mt, AbortedSubmissionSettled as n, ApprovalPendingSuspension as na, AppendReservedSettlement as ni, ThreadRead as nn, SubmissionState as no, turnApprovalsBatchId as nr, ToolCallSettled as nt, CURRENT_CANONICAL_SCHEMA_VERSION as o, ChildBudgetReservationRequest as oa, AwaitApprovalDecision as oi, ThreadStoreFailure as on, SuspensionSnapshot as oo, turnPreparedBatchId as or, WorkerAdmission as ot, CompletedSubmissionSettled as p, Claim as pa, CompleteMaterialization as pi, SubmissionStatus_d_exports as pn, settlementFailureFromRecord as po, ExplainedSubmission as pr, WorkerReportingIntent as pt, SubmissionSettled as q, SettlementReservationSnapshot as qa, AdmissionIndeterminate as qi, toolApprovalRequestRecordId as qn, definitionDigestsEqual as qr, SaveCheckpointRequest as qt, AgentUpdateEmitted as r, AttachChildToReservationRequest as ra, ApplyInput as ri, ThreadRecoveryCheckpoints as rn, SuspendRequest as ro, turnBatchId as rr, ToolCallUnknown as rt, CanonicalBatch as s, ChildBudgetReservationSnapshot as sa, AwaitChildAdmissionResolution as si, ThreadStore_d_exports as sn, UnknownResolution as so, turnResponseBatch as sr, WorkerInputCompleted as st, AbortRequested as t, ApprovalDecisionIntent as ta, digestJson as ti, ThreadObservation as tn, SubmissionSnapshot as to, toolStepSettledRecordId as tr, ToolCallResolved as tt, CanonicalRecordPayload as u, ChildReservationStatus as ua, AwaitParentEstablishment as ui, PendingSubmission as un, UnknownResolutionIntent as uo, turnResultsBatchId as ur, WorkerOriginRecorded as ut, FailedSubmissionSettled as v, JoinSnapshot as va, MarkUnknown as vi, RunJournal_d_exports as vn, submissionSettlementBatchId as vo, IntegrityReport as vr, DurableApprovalResolver as vt, ModelResponseInterrupted as w, MarkReadyRequest as wa, RecoveryDecision as wi, compactionRecordId as wn, RECOVERY_DECISION_MEANINGS as wr, DurableResolveFailure as wt, MAX_PERSISTED_JSON_DEPTH as x, LedgerError as xa, OpenToolCallEvidence as xi, childIdempotencyKeyFor as xn, ObligationReport as xr, DurableObligationFailure as xt, MAX_PERSISTED_JSON_BYTES as y, JoiningClaim as ya, NoAction as yi, TurnCommitInput as yn, submissionSettlementId as yo, ObligationBlockedOn as yr, DurableAwaitFailure as yt, RunPolicyUsageReserved as z, ResolutionCompletedWithResult as za, classifyRecovery as zi, subagentJoinedRecordId as zn, BindingUnavailable as zr, threadCreatedRecordId as zt };
-//# sourceMappingURL=Records-CMByd1eD.d.mts.map
+export { ToolCallPrepared as $, SubmissionLookupById as $a, ApprovalConflict as $i, toolCallResolvedRecordId as $n, digestDefinition as $r, ThreadExport as $t, ProducerId as A, ParentLinkage as Aa, RepairReadiness as Ai, modelResponseRecordId as An, RetryCommand as Ar, DurableSubmitAgent as At, RunStartedRecord as B, ResolutionNeverHappened as Ba, AbortCommand as Bi, runStartedRecordId as Bn, BindingUnavailable as Br, threadCreatedBatchId as Bt, ModelCompleted as C, MarkJoinedRequest as Ca, PropagateChildAbort as Ci, childIdempotencyKeyFor as Cn, ObligationEntry as Cr, DurableObligationFailure as Ct, PeerMessagePrepared as D, OwnershipRenewal as Da, ReleaseOrphanChildReservation as Di, markUnknownBatchId as Dn, RECOVERY_DECISION_MEANINGS as Dr, DurableRetryFailure as Dt, ObservationOffset as E, OwnershipLost as Ea, Recovery_d_exports as Ei, compactionRecordId as En, ObligationThresholds as Er, DurableResolveFailure as Et, ReplayContract as F, RenewOwnershipRequest as Fa, ResumeWaitingParent as Fi, runCompletionDigest as Fn, recoveryDecisionMeaning as Fr, DurableWorkerRequirements as Ft, SubagentRequested as G, SettlementFinalization as Ga, AdmissionFence as Gi, subagentRequestedBatchId as Gn, ResolvedBinding as Gr, FenceRejected as Gt, SettlementOutcome as H, RevertJoiningRequest as Ha, AbortIntentRequest as Hi, subagentJoinedRecordId as Hn, DurableWorkerBinding as Hr, AppendConflict as Ht, RunCompleted as I, ReservedChildBudget as Ia, RevertJoining as Ii, runDurationBatchId as In, renderRecoveryExplanation as Ir, RecoveryReport as It, SubmissionSettledRecord as J, SubmissionAdmissionFence as Ja, AdmissionNotAdmitted as Ji, subagentStartedRecordId as Jn, definitionDigestsEqual as Jr, MAX_THREAD_EXPORT_RECORDS as Jt, SubagentStarted as K, SettlementReservation as Ka, AdmissionGroup as Ki, subagentRequestedRecordId as Kn, compileBindingContracts as Kr, FencedAppendRequest as Kt, RunDurationExhausted as L, ReservedSettlement as La, SettleAborted as Li, runDurationRecordId as Ln, AgentRegistration_d_exports as Lr, childReservationIdFor as Lt, RecordId as M, RecoverySnapshotRequest as Ma, ResumeFromTurnBoundary as Mi, projectRunJournalStream as Mn, RetryRefused as Mr, DurableSubmitOptions as Mt, Records_d_exports as N, ReleaseChildBudgetRequest as Na, ResumePendingToolBatch as Ni, promptFromCanonicalRecords as Nn, obligationSeverityOf as Nr, DurableVerifyFailure as Nt, PersistedJson as O, OwnershipSnapshot as Oa, RepairInputMarker as Oi, modelResponseInterruptedBatchId as On, RecoveryDisposition as Or, DurableRuntimeConfig as Ot, RepairAnnotated as P, ReleaseOwnershipRequest as Pa, ResumeSuspended as Pi, runCompletedRecordId as Pn, predictRecoveryDisposition as Pr, DurableWorkerFailure as Pt, ToolApprovalRequested as Q, SubmissionLookup as Qa, AdmissionResult as Qi, toolCallResolutionBatchId as Qn, digestCanonicalBatch as Qr, ThreadCheckpoints as Qt, RunFailed as R, ResolutionAbortSubmission as Ra, SettleJoinedWithHost as Ri, runIdForSubmission as Rn, AgentAttemptContext as Rr, recoveryRepairBatchId as Rt, MAX_PERSISTED_JSON_NODES as S, MarkInputAppliedRequest as Sa, PendingApprovalEvidence as Si, approvalDecisionBatchId as Sn, ObligationBlockedOn as Sr, DurableExplainFailure as St, ModelResponseRecorded as T, MarkUnknownRequest as Ta, RecoveryEvidence as Ti, compactionBatchId as Tn, ObligationSeverity as Tr, DurableProgressFailure as Tt, SubagentJoined as U, Settlement as Ua, AdmissionAdmitted as Ui, subagentLineageBatchId as Un, ExecutableAgentBinding as Ur, AppendResult as Ut, SettlementFailureDiagnostic as V, ResolutionSafeToRetry as Va, AbortIntent as Vi, subagentJoinBatchId as Vn, DurableBindingFailure as Vr, threadCreatedRecordId as Vt, SubagentLineageRecorded as W, SettlementConflict as Wa, AdmissionConflict as Wi, subagentLineageRecordId as Wn, ReplayVersions as Wr, CheckpointRejected as Wt, ThreadCreated as X, SubmissionLedgerFailure as Xa, AdmissionRequest as Xi, toolApprovalRequestRecordId as Xn, Digest_d_exports as Xr, SaveRecoveryCheckpointRequest as Xt, SubtreeBudgetReserved as Y, SubmissionLedger as Ya, AdmissionPolicyError as Yi, toolApprovalDecisionRecordId as Yn, DigestError as Yr, SaveCheckpointRequest as Yt, ToolApprovalDecided as Z, SubmissionLedger_d_exports as Za, AdmissionResolution as Zi, toolCallPreparedRecordId as Zn, EMPTY_TAIL_DIGEST as Zr, ThreadCheckpoint as Zt, Digest as _, InputAppliedMarker as _a, FinalizeLedgerFromHistory as _i, RunJournalError as _n, submissionInputRecordId as _o, ExplainedUnknownCall as _r, DurableAgentRuntime as _t, BatchId as a, ChildAttachmentSnapshot as aa, ApplyUnknownResolutions as ai, ThreadRecoveryCheckpoints as an, SuspensionReason as ao, turnApprovalsBatchId as ar, ToolStepSettled as at, MAX_PERSISTED_JSON_COLLECTION_LENGTH as b, LedgerCapabilities as ba, OpenDelegationCallEvidence as bi, RunJournal_d_exports as bn, submissionSettlementRecordId as bo, IntegrityCheckStatus as br, DurableApprovalResolver as bt, CanonicalRecord as c, ChildReservationConflict as ca, AwaitChildSettlement as ci, ThreadStoreFailure as cn, UnknownResolutionCommand as co, turnIdForRun as cr, WorkerAdmission as ct, CanonicalSequence as d, ChildSettledNotification as da, AwaitUnknownResolution as di, ThreadTailRequest as dn, WaitingChild as do, turnResponseBatchId as dr, WorkerOrigin as dt, ApprovalDecisionCommand as ea, digestDefinitions as ei, ThreadExportRequest as en, SubmissionLookupByKey as eo, toolCallResultBatchId as er, ToolCallResolution as et, CompactionCreated as f, ChildSettledOutcome as fa, CompleteChildAdmission as fi, PendingSubmission as fn, WaitingForChildSuspension as fo, turnResultsBatch as fr, WorkerOriginRecorded as ft, DeploymentId as g, DEFAULT_OWNERSHIP_LEASE_DURATION as ga, EnsureWaitingForChild as gi, JournalBoundary as gn, submissionInputBatchId as go, ExplainedSubmission as gr, DurableAbortFailure as gt, DefinitionDigests as h, ClaimRequest as ha, DelegationAdmissionEvidence as hi, SubmissionStatus_d_exports as hn, submissionAbortRecordId as ho, ExplainedEvidence as hr, WorkerReportingIntent as ht, ApprovalDecision as i, BeginChildBudgetReleaseRequest as ia, ApplyJoinAccounting as ii, ThreadRead as in, SuspensionOutcome as io, toolStepSettledRecordId as ir, ToolOperation as it, RecordEnvelope as j, RecoverySnapshot as ja, RepairSubagentStartLink as ji, projectRunJournal as jn, RetryRefusalReason as jr, DurableSubmitFailure as jt, ProducerEpoch as k, OwnershipToken as ka, RepairJoinMarker as ki, modelResponseInterruptedRecordId as kn, RecoveryExplanation as kr, DurableRuntimeConfigOptions as kt, CanonicalRecordEnvelope as l, ChildReservationId as la, AwaitHostSettlement as li, ThreadStore_d_exports as ln, UnknownResolutionConflict as lo, turnPreparedBatchId as lr, WorkerInputCompleted as lt, DefinitionDigestInput as m, ClaimJoiningRequest as ma, DeclaredPendingBatchEvidence as mi, SubmissionStatus as mn, submissionAbortBatchId as mo, Admin_d_exports as mr, WorkerReportRefused as mt, AbortedSubmissionSettled as n, ApprovalPendingSuspension as na, AppendReservedSettlement as ni, ThreadNotMaterialized as nn, SubmissionState as no, toolCallUnknownRecordId as nr, ToolCallSettled as nt, CURRENT_CANONICAL_SCHEMA_VERSION as o, ChildBudgetReservationRequest as oa, AwaitApprovalDecision as oi, ThreadStore as on, SuspensionSnapshot as oo, turnBatchId as or, ToolUnavailable as ot, CompletedSubmissionSettled as p, Claim as pa, CompleteMaterialization as pi, SettledSubmission as pn, settlementFailureFromRecord as po, turnResultsBatchId as pr, WorkerReportPrepared as pt, SubmissionSettled as q, SettlementReservationSnapshot as qa, AdmissionIndeterminate as qi, subagentStartedBatchId as qn, compileRegistrations as qr, LoadCheckpointRequest as qt, AgentUpdateEmitted as r, AttachChildToReservationRequest as ra, ApplyInput as ri, ThreadObservation as rn, SuspendRequest as ro, toolStepSettledBatchId as rr, ToolCallUnknown as rt, CanonicalBatch as s, ChildBudgetReservationSnapshot as sa, AwaitChildAdmissionResolution as si, ThreadStoreError as sn, UnknownResolution as so, turnCanonicalBatch as sr, UserInputRecorded as st, AbortRequested as t, ApprovalDecisionIntent as ta, digestJson as ti, ThreadMaterialization as tn, SubmissionSnapshot as to, toolCallSettledRecordId as tr, ToolCallResolved as tt, CanonicalRecordPayload as u, ChildReservationStatus as ua, AwaitParentEstablishment as ui, ThreadTail as un, UnknownResolutionIntent as uo, turnResponseBatch as ur, WorkerInputRequested as ut, FailedSubmissionSettled as v, JoinSnapshot as va, MarkUnknown as vi, RunJournalProjection as vn, submissionSettlementBatchId as vo, IntegrityCheck as vr, DurableAgentRuntime_d_exports as vt, ModelResponseInterrupted as w, MarkReadyRequest as wa, RecoveryDecision as wi, childThreadIdFor as wn, ObligationReport as wr, DurableObserveOptions as wt, MAX_PERSISTED_JSON_DEPTH as x, LedgerError as xa, OpenToolCallEvidence as xi, TurnCommitInput as xn, IntegrityReport as xr, DurableAwaitFailure as xt, MAX_PERSISTED_JSON_BYTES as y, JoiningClaim as ya, NoAction as yi, RunJournalUsage as yn, submissionSettlementId as yo, IntegrityCheckName as yr, DurableApprovalFailure as yt, RunPolicyUsageReserved as z, ResolutionCompletedWithResult as za, classifyRecovery as zi, runStartedBatchId as zn, AgentRegistration as zr, recoveryRepairRecordId as zt };
+//# sourceMappingURL=Records-BIiRLqlz.d.mts.map