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

package/dist/Records-BAGkekt8.d.mts

@@ -0,0 +1,3570 @@
+import { c as SettlementId, d as ToolCallId, f as TurnId, l as SubmissionId, s as RunId, t as AgentId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { d as SubagentReservationAmounts, l as SubagentGrant, o as SubagentDelegationCaps, s as SubagentExecutionFailure, u as SubagentParentLink } from "./SubagentContract-DdT7Cqe6.mjs";
+import { a as Receipt, i as QueueSequence, n as JoinedToHost, r as Principal, t as IdempotencyKey } from "./Receipt-BAHyigAF.mjs";
+import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
+import { c as Selection, l as Snapshot } from "./ToolExposure-r2eOWk4F.mjs";
+import { l as RunUsageSummary, r as ModelCallUsage, s as RunTotals } from "./Usage-Dx0aknfk.mjs";
+import { a as ExhaustedLimit } from "./RunEvent-DIrzkjLr.mjs";
+import { t as ThreadHistory } from "./ThreadHistory-tS1KwxHR.mjs";
+import { a as AgentInputError } from "./AgentError-CggcAQ7V.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-CetmQrf3.mjs";
+import { T as RunDispositionDeclaration, _ as InstructionSource, c as Definition, m as InputPromptSource, n as Any, r as AnyDefinition, v as ModelServices } from "./Agent-CN0EWRsR.mjs";
+import { t as RunPolicyUsage } from "./RunPolicyUsage-ClZxyR46.mjs";
+import { a as WorkerError } from "./Worker-CaPYykpe.mjs";
+import { G as RunToolAuthorization, O as RunCostEstimator, h as RunApprovalHook, x as RunContextPreparation } from "./RunOptions-g1aigcKI.mjs";
+import { _ as MessagingError, f as InputMessage, t as MessagingHost } from "./MessagingHost-CRk0kXzT.mjs";
+import "./Messaging-CkcIdt4I.mjs";
+import { c as WorkerReportPreparationFailure, i as SubagentHost, l as WorkerReporting } from "./SubagentHost-CJUBQlcc.mjs";
+import { p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements } from "./AgentRuntime-uxR_a4VM.mjs";
+import { n as DurableRuntimeFailpoint, r as DurableRuntimeFailpointError } from "./DurableFailpoint-Oinuuedm.mjs";
+import { o as OperationDenied } from "./OperationAuthorizer-TzcQtpX5.mjs";
+import { s as ToolReconciler } from "./ToolReconciler-DQVaJfpE.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";
+declare namespace SubmissionLedger_d_exports {
+  export { AbortCommand, AbortIntent, AbortIntentRequest, AdmissionAdmitted, AdmissionConflict, AdmissionFence, AdmissionGroup, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionPolicyError, AdmissionRequest, AdmissionResolution, AdmissionResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, ApprovalPendingSuspension, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationId, ChildReservationStatus, ChildSettledNotification, ChildSettledOutcome, Claim, ClaimJoiningRequest, ClaimRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, IdempotencyKey, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, ParentLinkage, Principal, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, ResolutionAbortSubmission, ResolutionCompletedWithResult, ResolutionNeverHappened, ResolutionSafeToRetry, RevertJoiningRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SubmissionAdmissionFence, SubmissionLedger, SubmissionLedgerFailure, SubmissionLookup, SubmissionLookupById, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionOutcome, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WaitingChild, WaitingForChildSuspension, settlementFailureFromRecord, submissionAbortBatchId, submissionAbortRecordId, submissionInputBatchId, submissionInputRecordId, submissionSettlementBatchId, submissionSettlementId, submissionSettlementRecordId };
+}
+/**
+ * Opaque proof that one Attempt currently owns a Submission's lane. It authorizes ledger
+ * mutations only; canonical-log fencing authority remains the producer epoch (DUR-006).
+ */
+declare const OwnershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+type OwnershipToken = typeof OwnershipToken.Type;
+/**
+ * Ledger lifecycle states for one Submission. `settled` is the only terminal state; every other
+ * state carries an outstanding accepted-work obligation (Accepted-work Contract, DUR-002).
+ *
+ * Phase 5 states:
+ *
+ * - `joining` — a queued Submission claimed by an active host Run, before its canonical
+ *   `UserInputRecorded` append; recovery reverts it to `ready` (DUR-016).
+ * - `joined` — the input is canonical and linked to its host; the Submission settles WITH the
+ *   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).
+ *
+ * `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.
+ */
+declare const SubmissionState: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+type SubmissionState = typeof SubmissionState.Type;
+/**
+ * Default ownership lease duration (D5). The lease is a liveness hint that makes an abandoned
+ * claim reclaimable; correctness never depends on it because every canonical append is fenced by
+ * producer epoch. Adapters expose this as configuration and use this value when unconfigured.
+ */
+declare const DEFAULT_OWNERSHIP_LEASE_DURATION: Duration.Duration;
+declare const LedgerCapabilities_base: Schema.Class<LedgerCapabilities, Schema.Struct<{
+  readonly durability: Schema.Literals<readonly ["durable-node", "durable-cloudflare", "non-durable"]>;
+}>, {}>;
+/**
+ * What a SubmissionLedger adapter claims about itself. `durable-node` asserts single-node
+ * process-crash durability (fsync-backed storage); `durable-cloudflare` asserts the same
+ * single-serialized-owner crash durability through Durable Object storage output gates;
+ * `non-durable` marks reference adapters whose state does not survive the process (in-memory
+ * conformance/test adapters). The label is an honest self-description for reports and
+ * evidence — no runtime behavior branches on it.
+ */
+declare class LedgerCapabilities extends LedgerCapabilities_base {}
+declare const ParentLinkage_base: Schema.Class<ParentLinkage, Schema.Struct<{
+  readonly parentSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly parentToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, {}>;
+/**
+ * Immutable lineage from a child Submission to the exact parent Tool Call that established it
+ * (spec §12 step 5, SUB-004). Recorded once at admission and never rewritten; it is an
+ * identifier, not an authorization capability (D10) — the join path verifies the canonical
+ * Parent Link records, never this marker alone.
+ */
+declare class ParentLinkage extends ParentLinkage_base {}
+/** Host-owned policy coordinates, interpreted only by the destination transaction owner. */
+declare const AdmissionFence: Schema.Struct<{
+  readonly policyId: Schema.NonEmptyString;
+  readonly key: Schema.NonEmptyString;
+  readonly revision: Schema.NonEmptyString;
+}>;
+type AdmissionFence = typeof AdmissionFence.Type;
+declare const AdmissionGroup: Schema.NonEmptyString;
+declare const AdmissionPolicyError_base: Schema.Class<AdmissionPolicyError, Schema.TaggedStruct<"AdmissionPolicyError", {
+  readonly reason: Schema.Literals<readonly ["refused", "unavailable", "occupied"]>;
+  readonly code: Schema.NonEmptyString;
+}>, import("effect/Cause").YieldableError>;
+/** Fresh admission alone may be refused; unavailability never proves non-admission. */
+declare class AdmissionPolicyError extends AdmissionPolicyError_base {}
+declare const AdmissionRequest_base: Schema.Class<AdmissionRequest, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+  readonly idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly agentDigests: typeof DefinitionDigests;
+  readonly deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+  readonly inputPayload: Schema.declare<Schema.Json, Schema.Json>;
+  readonly inputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly parentLinkage: Schema.optionalKey<typeof ParentLinkage>;
+  readonly workerAdmission: Schema.optionalKey<Schema.Struct<{
+    readonly origin: Schema.Struct<{
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"tool">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+        readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+      }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"programmatic">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>]>;
+      readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+      readonly targetDigests: typeof DefinitionDigests;
+      readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+      readonly budget: Schema.Struct<{
+        readonly caps: typeof SubagentDelegationCaps;
+        readonly allocation: typeof SubagentReservationAmounts;
+        readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+      }>;
+      readonly grant: typeof SubagentGrant;
+      readonly depth: Schema.Int;
+      readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+      readonly firstMessageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      readonly createdAtMillis: Schema.Natural;
+      readonly expiresAtMillis: Schema.Natural;
+      readonly reporting: Schema.optionalKey<Schema.Struct<{
+        readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+        readonly sourceDigests: typeof DefinitionDigests;
+        readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+      }>>;
+    }>;
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+    readonly createdAtMillis: Schema.Natural;
+    readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+    readonly deliveryPrincipal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+    readonly reportKind: Schema.optionalKey<Schema.Literal<"update">>;
+  }>>;
+  readonly messageAdmission: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly peerName: Schema.NonEmptyString;
+    readonly sender: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly returnAddress: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>>;
+  }>, Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerCompletion">;
+    readonly budgetExhausted: Schema.Boolean;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly report: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literal<"completed">;
+      readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+      readonly failure: typeof SubagentExecutionFailure;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerUpdate">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly update: typeof Update;
+  }>]>]>>;
+  readonly admissionGroup: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly admissionFence: Schema.optionalKey<Schema.Struct<{
+    readonly policyId: Schema.NonEmptyString;
+    readonly key: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>>;
+}>, {}>;
+/**
+ * Durable admission input. `inputDigest` must be the digest of the canonical JSON encoding of
+ * `inputPayload` (see `digestJson`); admission idempotency compares digests, never re-encodes.
+ * `agentId`/`agentDigests`/`deploymentId` are persisted so recovery can complete Thread
+ * materialization without the submitting client. `parentLinkage` is present exactly when the
+ * Submission is a durable attached child (spec §12); an admission replay must repeat the same
+ * linkage (or its absence) or fail with `AdmissionConflict`.
+ */
+declare class AdmissionRequest extends AdmissionRequest_base {}
+declare const AdmissionResult_base: Schema.Class<AdmissionResult, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly queueSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/QueueSequence">;
+  readonly state: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+  readonly replayed: Schema.Boolean;
+}>, {}>;
+/**
+ * The committed admission row. `replayed` is true when an identical (thread, principal,
+ * idempotencyKey, inputDigest) admission already existed; the original identities are returned
+ * unchanged so a client retry resumes rather than duplicates (DUR-001).
+ */
+declare class AdmissionResult extends AdmissionResult_base {}
+declare const MarkReadyRequest_base: Schema.Class<MarkReadyRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+declare class MarkReadyRequest extends MarkReadyRequest_base {}
+declare const SubmissionLookupById_base: Schema.Class<SubmissionLookupById, Schema.TaggedStruct<"SubmissionLookupById", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+declare class SubmissionLookupById extends SubmissionLookupById_base {}
+declare const SubmissionLookupByKey_base: Schema.Class<SubmissionLookupByKey, Schema.TaggedStruct<"SubmissionLookupByKey", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+  readonly idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+}>, {}>;
+declare class SubmissionLookupByKey extends SubmissionLookupByKey_base {}
+/** Lookup by Submission identity or by the scoped client idempotency key. */
+declare const SubmissionLookup: Schema.Union<readonly [typeof SubmissionLookupById, typeof SubmissionLookupByKey]>;
+type SubmissionLookup = typeof SubmissionLookup.Type;
+declare const SubmissionSnapshot_base: Schema.Class<SubmissionSnapshot, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly queueSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/QueueSequence">;
+  readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+  readonly idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly agentDigests: typeof DefinitionDigests;
+  readonly deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+  readonly inputPayload: Schema.declare<Schema.Json, Schema.Json>;
+  readonly inputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly state: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+  readonly settledOutcome: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly readyAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+  readonly admissionGroup: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly admissionFence: Schema.optionalKey<Schema.Struct<{
+    readonly policyId: Schema.NonEmptyString;
+    readonly key: Schema.NonEmptyString;
+    readonly revision: Schema.NonEmptyString;
+  }>>;
+  readonly parentLinkage: Schema.optionalKey<typeof ParentLinkage>;
+  readonly workerAdmission: Schema.optionalKey<Schema.Struct<{
+    readonly origin: Schema.Struct<{
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"tool">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+        readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+      }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"programmatic">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>]>;
+      readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+      readonly targetDigests: typeof DefinitionDigests;
+      readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+      readonly budget: Schema.Struct<{
+        readonly caps: typeof SubagentDelegationCaps;
+        readonly allocation: typeof SubagentReservationAmounts;
+        readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+      }>;
+      readonly grant: typeof SubagentGrant;
+      readonly depth: Schema.Int;
+      readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+      readonly firstMessageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      readonly createdAtMillis: Schema.Natural;
+      readonly expiresAtMillis: Schema.Natural;
+      readonly reporting: Schema.optionalKey<Schema.Struct<{
+        readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+        readonly sourceDigests: typeof DefinitionDigests;
+        readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+      }>>;
+    }>;
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+    readonly createdAtMillis: Schema.Natural;
+    readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+    readonly deliveryPrincipal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+    readonly reportKind: Schema.optionalKey<Schema.Literal<"update">>;
+  }>>;
+  readonly messageAdmission: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly peerName: Schema.NonEmptyString;
+    readonly sender: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly returnAddress: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>>;
+  }>, Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerCompletion">;
+    readonly budgetExhausted: Schema.Boolean;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly report: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literal<"completed">;
+      readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+      readonly failure: typeof SubagentExecutionFailure;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerUpdate">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly update: typeof Update;
+  }>]>]>>;
+}>, {}>;
+/** The full durable ledger view of one Submission. */
+declare class SubmissionSnapshot extends SubmissionSnapshot_base {}
+declare const AdmissionNotAdmitted_base: Schema.Class<AdmissionNotAdmitted, Schema.TaggedStruct<"NotAdmitted", {}>, {}>;
+/** The authoritative store proves the scoped idempotency key was never admitted (SUB-031). */
+declare class AdmissionNotAdmitted extends AdmissionNotAdmitted_base {}
+declare const AdmissionAdmitted_base: Schema.Class<AdmissionAdmitted, Schema.TaggedStruct<"Admitted", {
+  readonly submission: typeof SubmissionSnapshot;
+}>, {}>;
+/** The scoped idempotency key was admitted; the full Submission snapshot is authoritative. */
+declare class AdmissionAdmitted extends AdmissionAdmitted_base {}
+declare const AdmissionIndeterminate_base: Schema.Class<AdmissionIndeterminate, Schema.TaggedStruct<"Indeterminate", {
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * The adapter cannot currently prove admission or its absence (e.g. the authoritative child
+ * owner is unreachable on a partitioned platform). Callers wait and retry; an indeterminate
+ * answer NEVER permits a second admission attempt (SUB-031).
+ */
+declare class AdmissionIndeterminate extends AdmissionIndeterminate_base {}
+/**
+ * The tri-state answer of `resolveAdmission` (spec §12: "absence from an eventually consistent
+ * projection is never proof"). Single strongly consistent stores derive `NotAdmitted`/`Admitted`
+ * from a direct lookup; only adapters that can genuinely fail to reach the authoritative owner
+ * answer `Indeterminate`.
+ */
+declare const AdmissionResolution: Schema.Union<readonly [typeof AdmissionNotAdmitted, typeof AdmissionAdmitted, typeof AdmissionIndeterminate]>;
+type AdmissionResolution = typeof AdmissionResolution.Type;
+declare const ClaimRequest_base: Schema.Class<ClaimRequest, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly producerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ProducerId">;
+}>, {}>;
+declare class ClaimRequest extends ClaimRequest_base {}
+declare const Claim_base: Schema.Class<Claim, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly attemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly producerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+  readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
+  readonly inputPayload: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/**
+ * One granted ownership period. `producerEpoch` is the fencing token for every canonical append
+ * this Attempt performs; `leaseExpiresAt` is when the claim becomes reclaimable unless renewed.
+ */
+declare class Claim extends Claim_base {}
+declare const RenewOwnershipRequest_base: Schema.Class<RenewOwnershipRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+}>, {}>;
+declare class RenewOwnershipRequest extends RenewOwnershipRequest_base {}
+declare const OwnershipRenewal_base: Schema.Class<OwnershipRenewal, Schema.Struct<{
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+/**
+ * A renewed lease. Adapters MAY rotate the token; callers must use the returned token for every
+ * later ledger mutation.
+ */
+declare class OwnershipRenewal extends OwnershipRenewal_base {}
+declare const ReleaseOwnershipRequest_base: Schema.Class<ReleaseOwnershipRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+}>, {}>;
+declare class ReleaseOwnershipRequest extends ReleaseOwnershipRequest_base {}
+declare const MarkInputAppliedRequest_base: Schema.Class<MarkInputAppliedRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+  readonly sequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+}>, {}>;
+/**
+ * The canonical position of the applied `UserInputRecorded` record for one Submission.
+ */
+declare class MarkInputAppliedRequest extends MarkInputAppliedRequest_base {}
+declare const InputAppliedMarker_base: Schema.Class<InputAppliedMarker, Schema.Struct<{
+  readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+  readonly sequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+}>, {}>;
+declare class InputAppliedMarker extends InputAppliedMarker_base {}
+declare const SettlementReservation_base: Schema.Class<SettlementReservation, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  readonly record: typeof RecordEnvelope;
+  readonly recordDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/**
+ * Reservation of the single exact settlement record for one Submission (DUR-011). `record` is
+ * the complete canonical envelope that will be appended — including `createdAt` — so a recovering
+ * Attempt can re-append byte-identical content without a batch-digest conflict. `recordDigest`
+ * must be the digest of the canonical JSON encoding of the Schema-encoded envelope.
+ */
+declare class SettlementReservation extends SettlementReservation_base {}
+declare const ReservedSettlement_base: Schema.Class<ReservedSettlement, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  readonly record: typeof RecordEnvelope;
+  readonly recordDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly replayed: Schema.Boolean;
+}>, {}>;
+/**
+ * The committed reservation. `replayed` is true when an identical reservation already existed;
+ * the stored exact record is returned so recovery appends precisely what was reserved.
+ */
+declare class ReservedSettlement extends ReservedSettlement_base {}
+declare const SettlementFinalization_base: Schema.Class<SettlementFinalization, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+}>, {}>;
+declare class SettlementFinalization extends SettlementFinalization_base {}
+declare const Settlement_base: Schema.Class<Settlement, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  /** Schema-encoded application disposition materialized from the exact canonical reservation. */
+  readonly runDisposition: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  /** Canonical aggregate of model usage and estimated spend for this Run. */
+  readonly usageSummary: Schema.optionalKey<typeof RunUsageSummary>;
+  /** Present exactly for `failed`; its Schema rejects excess keys before canonical projection. */
+  readonly failure: Schema.optionalKey<Schema.Struct<{
+    readonly errorTag: Schema.NonEmptyString;
+    readonly message: Schema.String;
+  }>>;
+  readonly settledAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+/** The single durable terminal outcome recorded for one accepted Submission (DUR-002). */
+declare class Settlement extends Settlement_base {}
+/**
+ * Project the bounded failed-settlement diagnostic from an already Schema-validated exact
+ * reservation. Storage adapters use this when materializing their operational Settlement value;
+ * the canonical record remains the authority.
+ */
+declare const settlementFailureFromRecord: (record: RecordEnvelope) => SettlementFailureDiagnostic | undefined;
+declare const AbortCommand_base: Schema.Class<AbortCommand, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * A durable abort command (durability §13). Field bounds are exactly those of the canonical
+ * `AbortRequested` payload so the intent can become canonical without re-validation.
+ */
+declare class AbortCommand extends AbortCommand_base {}
+declare const AbortIntent_base: Schema.Class<AbortIntent, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+  readonly requestedAt: Schema.DateTimeUtcFromString;
+  readonly canonicalRecordId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">>;
+}>, {}>;
+/**
+ * The recorded abort intent. `canonicalRecordId` is present once the corresponding canonical
+ * `AbortRequested` record has been appended (its identity is deterministic; see
+ * `submissionAbortRecordId`).
+ */
+declare class AbortIntent extends AbortIntent_base {}
+declare const AbortIntentRequest_base: Schema.Class<AbortIntentRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Address one lane-local abort intent without loading unrelated recovery state. */
+declare class AbortIntentRequest extends AbortIntentRequest_base {}
+declare const ClaimJoiningRequest_base: Schema.Class<ClaimJoiningRequest, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly hostSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly maxCount: Schema.Int;
+}>, {}>;
+/**
+ * Atomic claim of the contiguous ready prefix of strictly-later queued Submissions for joining
+ * into the active host Run (plan §2.5). Fenced by the host Attempt's ownership token — no epoch
+ * bump, the host already owns the lane. An `admitted`-but-not-`ready` row breaks the prefix;
+ * an aborted-settled row is a closed obligation and is skipped as a non-gap (P7 §7(c)).
+ */
+declare class ClaimJoiningRequest extends ClaimJoiningRequest_base {}
+declare const JoiningClaim_base: Schema.Class<JoiningClaim, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly queueSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/QueueSequence">;
+  readonly inputPayload: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/** One queued Submission transitioned to `joining` under the host's ownership. */
+declare class JoiningClaim extends JoiningClaim_base {}
+declare const MarkJoinedRequest_base: Schema.Class<MarkJoinedRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+  readonly sequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+}>, {}>;
+/**
+ * The canonical position of one joined Submission's `UserInputRecorded` record (`input:{sid}`).
+ * Marking transitions `joining → joined` and records the host linkage established at claim time.
+ */
+declare class MarkJoinedRequest extends MarkJoinedRequest_base {}
+declare const RevertJoiningRequest_base: Schema.Class<RevertJoiningRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/**
+ * Recovery-only revert of a `joining` Submission whose canonical input append never committed
+ * (DUR-016): `joining → ready`, idempotent, a no-op when the Submission already joined.
+ */
+declare class RevertJoiningRequest extends RevertJoiningRequest_base {}
+declare const ApprovalPendingSuspension_base: Schema.Class<ApprovalPendingSuspension, Schema.TaggedStruct<"ApprovalPending", {
+  readonly toolCallIds: Schema.NonEmptyArray<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">>;
+}>, {}>;
+/**
+ * Why one Submission is durably suspended. Approval was the only Phase 5 reason; S2 adds
+ * `WaitingForChild` (spec §12 step 10) and the union keeps later suspension families (e.g.
+ * operator quarantine) additive.
+ */
+declare class ApprovalPendingSuspension extends ApprovalPendingSuspension_base {}
+declare const WaitingChild_base: Schema.Class<WaitingChild, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** One attached child a `waitingForChild` parent is durably waiting on (spec §12 step 10). */
+declare class WaitingChild extends WaitingChild_base {}
+declare const WaitingForChildSuspension_base: Schema.Class<WaitingForChildSuspension, Schema.TaggedStruct<"WaitingForChild", {
+  readonly children: Schema.NonEmptyArray<typeof WaitingChild>;
+}>, {}>;
+/**
+ * The parent Attempt ended without settling because attached durable children must settle and
+ * join first (spec §12 step 10, SUB-030). The suspended lane holds no worker permit; each listed
+ * child settles on its own Thread lane and `recordChildSettled` wakes the parent once
+ * every listed child is settled.
+ */
+declare class WaitingForChildSuspension extends WaitingForChildSuspension_base {}
+declare const SuspensionReason: Schema.Union<readonly [typeof ApprovalPendingSuspension, typeof WaitingForChildSuspension]>;
+type SuspensionReason = typeof SuspensionReason.Type;
+declare const SuspendRequest_base: Schema.Class<SuspendRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly reason: Schema.Union<readonly [typeof ApprovalPendingSuspension, typeof WaitingForChildSuspension]>;
+}>, {}>;
+/**
+ * Durable suspension of owned work (plan §2.6): `input-applied`/`running` → `suspended`, the
+ * ownership period ends, NO settlement occurs — the accepted-work obligation stays owed while
+ * the lane consumes no worker permit.
+ */
+declare class SuspendRequest extends SuspendRequest_base {}
+/**
+ * `suspended` when the lane is now durably waiting; `resume-immediately` when the suspension
+ * reason is already fully covered (a covering decision or child settlement raced ahead of the
+ * suspend transaction), so the caller resumes without releasing the lane.
+ */
+declare const SuspensionOutcome: Schema.Literals<readonly ["suspended", "resume-immediately"]>;
+type SuspensionOutcome = typeof SuspensionOutcome.Type;
+declare const ChildSettledNotification_base: Schema.Class<ChildSettledNotification, Schema.Struct<{
+  readonly parentSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/**
+ * A durable child-settlement notification for one waitingForChild parent (spec §12 step 10).
+ * The child's canonical Settlement is the authority; this command only drives the parent lane's
+ * wake transition.
+ */
+declare class ChildSettledNotification extends ChildSettledNotification_base {}
+/**
+ * `woken` when this notification completed the waiting set and the parent transitioned
+ * `suspended(WaitingForChild) → input-applied`; `still-waiting` while other listed children are
+ * unsettled; `not-waiting` when the parent is not (or no longer) suspended waiting on this
+ * child — including replays after a wake, so the operation is idempotent.
+ */
+declare const ChildSettledOutcome: Schema.Literals<readonly ["woken", "still-waiting", "not-waiting"]>;
+type ChildSettledOutcome = typeof ChildSettledOutcome.Type;
+/** Parent-owned child budget reservation identity, deterministically derived by the
+ * coordinator from the parent Run and Tool Call identity (spec §12 step 2). */
+declare const ChildReservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+type ChildReservationId = typeof ChildReservationId.Type;
+/**
+ * The reservation state machine (spec §12 steps 2 and 6): `reserved` while the child may still
+ * consume the allocation, `releasePending` once the final accounting decision is frozen, and
+ * `released` after the unused allocation returned exactly once.
+ */
+declare const ChildReservationStatus: Schema.Literals<readonly ["reserved", "releasePending", "released"]>;
+type ChildReservationStatus = typeof ChildReservationStatus.Type;
+declare const ChildBudgetReservationRequest_base: Schema.Class<ChildBudgetReservationRequest, Schema.Struct<{
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+  readonly parentSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly parentToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly allocation: Schema.declare<Schema.Json, Schema.Json>;
+  readonly allocationDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/**
+ * Creation input for one parent-owned child budget reservation. The allocation is an opaque
+ * Schema-encoded budget document (D8: adapters implement transitions only and never interpret
+ * budget dimensions); `allocationDigest` must be the digest of its canonical JSON encoding.
+ */
+declare class ChildBudgetReservationRequest extends ChildBudgetReservationRequest_base {}
+declare const ChildBudgetReservationSnapshot_base: Schema.Class<ChildBudgetReservationSnapshot, Schema.Struct<{
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+  readonly parentSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly parentToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly status: Schema.Literals<readonly ["reserved", "releasePending", "released"]>;
+  readonly allocation: Schema.declare<Schema.Json, Schema.Json>;
+  readonly allocationDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly accounting: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  readonly reservedAt: Schema.DateTimeUtcFromString;
+  readonly releaseBeganAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+  readonly releasedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+}>, {}>;
+/** One child budget reservation row as the port exposes it. */
+declare class ChildBudgetReservationSnapshot extends ChildBudgetReservationSnapshot_base {}
+declare const ReservedChildBudget_base: Schema.Class<ReservedChildBudget, Schema.Struct<{
+  readonly reservation: typeof ChildBudgetReservationSnapshot;
+  readonly replayed: Schema.Boolean;
+}>, {}>;
+/**
+ * The committed reservation. `replayed` is true when an identical reservation already existed;
+ * the stored row is returned unchanged so a recovering caller resumes rather than duplicates
+ * (SUB-016).
+ */
+declare class ReservedChildBudget extends ReservedChildBudget_base {}
+declare const AttachChildToReservationRequest_base: Schema.Class<AttachChildToReservationRequest, Schema.Struct<{
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+  readonly ownershipToken: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/OwnershipToken">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Records the admitted child on its reservation row (repairable from `SubagentStarted`). */
+declare class AttachChildToReservationRequest extends AttachChildToReservationRequest_base {}
+declare const BeginChildBudgetReleaseRequest_base: Schema.Class<BeginChildBudgetReleaseRequest, Schema.Struct<{
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+  readonly accounting: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/**
+ * Freezes the final consumed/released accounting decision (spec §12 join step 6). The
+ * accounting is an opaque Schema-encoded document replayed from the canonical `SubagentJoined`
+ * record (or the deterministic zero-consumed decision for an orphaned reservation), so the
+ * decision itself authorizes the transition — no ownership token is consulted (DUR-015).
+ */
+declare class BeginChildBudgetReleaseRequest extends BeginChildBudgetReleaseRequest_base {}
+declare const ReleaseChildBudgetRequest_base: Schema.Class<ReleaseChildBudgetRequest, Schema.Struct<{
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+}>, {}>;
+/** Applies the frozen accounting decision: `releasePending → released`, exactly once. */
+declare class ReleaseChildBudgetRequest extends ReleaseChildBudgetRequest_base {}
+declare const ApprovalDecisionCommand_base: Schema.Class<ApprovalDecisionCommand, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly decision: Schema.Literals<readonly ["approved", "denied"]>;
+  readonly resolver: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * A durable approval decision command (plan §2.6, `abort`-shaped). Field bounds are exactly those
+ * of the canonical `ToolApprovalDecided` payload so the intent can become canonical without
+ * re-validation.
+ */
+declare class ApprovalDecisionCommand extends ApprovalDecisionCommand_base {}
+declare const ApprovalDecisionIntent_base: Schema.Class<ApprovalDecisionIntent, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly decision: Schema.Literals<readonly ["approved", "denied"]>;
+  readonly resolver: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+  readonly decidedAt: Schema.DateTimeUtcFromString;
+  readonly canonicalRecordId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">>;
+}>, {}>;
+/**
+ * The recorded approval-decision intent, idempotent per `(submissionId, toolCallId)`.
+ * `canonicalRecordId` is present once the corresponding canonical `ToolApprovalDecided` record
+ * has been appended (see `toolApprovalDecisionRecordId`).
+ */
+declare class ApprovalDecisionIntent extends ApprovalDecisionIntent_base {}
+declare const MarkUnknownRequest_base: Schema.Class<MarkUnknownRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallIds: Schema.NonEmptyArray<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">>;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * 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.
+ */
+declare class MarkUnknownRequest extends MarkUnknownRequest_base {}
+declare const ResolutionCompletedWithResult_base: Schema.Class<ResolutionCompletedWithResult, Schema.TaggedStruct<"CompletedWithResult", {
+  readonly result: Schema.declare<Schema.Json, Schema.Json>;
+  readonly isFailure: Schema.Boolean;
+}>, {}>;
+/** The recovered supplier truth: the external effect completed with this exact result. */
+declare class ResolutionCompletedWithResult extends ResolutionCompletedWithResult_base {}
+declare const ResolutionNeverHappened_base: Schema.Class<ResolutionNeverHappened, Schema.TaggedStruct<"NeverHappened", {}>, {}>;
+/** The external effect provably never happened; the call may re-execute on resume. */
+declare class ResolutionNeverHappened extends ResolutionNeverHappened_base {}
+declare const ResolutionSafeToRetry_base: Schema.Class<ResolutionSafeToRetry, Schema.TaggedStruct<"SafeToRetry", {}>, {}>;
+/** The call is safe to repeat under the external system's idempotency contract. */
+declare class ResolutionSafeToRetry extends ResolutionSafeToRetry_base {}
+declare const ResolutionAbortSubmission_base: Schema.Class<ResolutionAbortSubmission, Schema.TaggedStruct<"AbortSubmission", {}>, {}>;
+/** Give up on the Submission: route into the abort path (unknown calls stay recorded; abort
+ * never claims external rollback, durability §13). */
+declare class ResolutionAbortSubmission extends ResolutionAbortSubmission_base {}
+/** How an authorized resolver closed one Unknown Outcome (DUR-017). */
+declare const UnknownResolution: Schema.Union<readonly [typeof ResolutionCompletedWithResult, typeof ResolutionNeverHappened, typeof ResolutionSafeToRetry, typeof ResolutionAbortSubmission]>;
+type UnknownResolution = typeof UnknownResolution.Type;
+declare const UnknownResolutionCommand_base: Schema.Class<UnknownResolutionCommand, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+  readonly resolution: Schema.Union<readonly [typeof ResolutionCompletedWithResult, typeof ResolutionNeverHappened, typeof ResolutionSafeToRetry, typeof ResolutionAbortSubmission]>;
+}>, {}>;
+/**
+ * A durable Unknown-Outcome resolution command (DUR-017, `abort`-shaped). Possession of the
+ * runtime service plus the mandatory `author`/`reason` audit fields is the Phase 5 authorization
+ * boundary — identical to `abort`; the authenticated operator surface is a P7 deliverable.
+ * Field bounds are exactly those of the canonical `ToolCallResolved` payload.
+ */
+declare class UnknownResolutionCommand extends UnknownResolutionCommand_base {}
+declare const UnknownResolutionIntent_base: Schema.Class<UnknownResolutionIntent, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+  readonly resolution: Schema.Union<readonly [typeof ResolutionCompletedWithResult, typeof ResolutionNeverHappened, typeof ResolutionSafeToRetry, typeof ResolutionAbortSubmission]>;
+  readonly resolvedAt: Schema.DateTimeUtcFromString;
+  readonly canonicalRecordId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">>;
+}>, {}>;
+/**
+ * The recorded resolution intent, idempotent per `(submissionId, toolCallId)`. The canonical
+ * `ToolCallResolved` (+ `ToolCallSettled` for `CompletedWithResult`) is appended by the recovery
+ * pass or the next owning Attempt; `canonicalRecordId` is present once it is.
+ */
+declare class UnknownResolutionIntent extends UnknownResolutionIntent_base {}
+declare const OwnershipSnapshot_base: Schema.Class<OwnershipSnapshot, Schema.Struct<{
+  readonly attemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+  readonly ownerProducerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ProducerId">;
+  readonly producerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+  readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+/** Current ownership as recovery sees it. The live owner's token is never exposed here. */
+declare class OwnershipSnapshot extends OwnershipSnapshot_base {}
+declare const SettlementReservationSnapshot_base: Schema.Class<SettlementReservationSnapshot, Schema.Struct<{
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  readonly record: typeof RecordEnvelope;
+  readonly recordDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly finalized: Schema.Boolean;
+}>, {}>;
+/** A settlement reservation as recovery sees it. */
+declare class SettlementReservationSnapshot extends SettlementReservationSnapshot_base {}
+declare const RecoverySnapshotRequest_base: Schema.Class<RecoverySnapshotRequest, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+declare class RecoverySnapshotRequest extends RecoverySnapshotRequest_base {}
+declare const JoinSnapshot_base: Schema.Class<JoinSnapshot, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly state: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+  readonly hostSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** One joined/joining Submission of a host Run, as the host's recovery sees it. */
+declare class JoinSnapshot extends JoinSnapshot_base {}
+declare const SuspensionSnapshot_base: Schema.Class<SuspensionSnapshot, Schema.Struct<{
+  readonly reason: Schema.Union<readonly [typeof ApprovalPendingSuspension, typeof WaitingForChildSuspension]>;
+  readonly suspendedAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+/** A durable suspension as recovery sees it. */
+declare class SuspensionSnapshot extends SuspensionSnapshot_base {}
+declare const ChildAttachmentSnapshot_base: Schema.Class<ChildAttachmentSnapshot, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childState: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+  readonly childOutcome: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+}>, {}>;
+/**
+ * One attached child of this parent as its recovery sees it: the reservation's recorded child
+ * plus that child's current lane state. A disposable derived view — the canonical
+ * `SubagentRequested`/`SubagentStarted` records and the child's own canonical Settlement remain
+ * the recovery truth (DUR-015).
+ */
+declare class ChildAttachmentSnapshot extends ChildAttachmentSnapshot_base {}
+declare const RecoverySnapshot_base: Schema.Class<RecoverySnapshot, Schema.Struct<{
+  readonly submission: typeof SubmissionSnapshot;
+  readonly ownership: Schema.optionalKey<typeof OwnershipSnapshot>;
+  readonly inputApplied: Schema.optionalKey<typeof InputAppliedMarker>;
+  readonly reservation: Schema.optionalKey<typeof SettlementReservationSnapshot>;
+  readonly abortIntent: Schema.optionalKey<typeof AbortIntent>;
+  readonly joins: Schema.$Array<typeof JoinSnapshot>;
+  readonly hostSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly suspension: Schema.optionalKey<typeof SuspensionSnapshot>;
+  readonly approvalDecisions: Schema.$Array<typeof ApprovalDecisionIntent>;
+  readonly unknownResolutions: Schema.$Array<typeof UnknownResolutionIntent>;
+  readonly childReservations: Schema.withConstructorDefault<Schema.$Array<typeof ChildBudgetReservationSnapshot>>;
+  readonly childAttachments: Schema.withConstructorDefault<Schema.$Array<typeof ChildAttachmentSnapshot>>;
+  readonly parentLinkage: Schema.optionalKey<typeof ParentLinkage>;
+}>, {}>;
+/**
+ * Everything the pure recovery classifier needs about one Submission, read strongly consistently
+ * (STORE-003). Canonical history still wins over every marker in this snapshot (DUR-015).
+ *
+ * Phase 5 fields: `joins` is the host-side view (every Submission `joining`/`joined` to this
+ * one); `hostSubmissionId` is the joined-side view; `suspension` mirrors the `suspended` state;
+ * `approvalDecisions` and `unknownResolutions` are the durable intents recorded against this
+ * Submission (empty when none exist).
+ *
+ * S2 fields: `childReservations`/`childAttachments` are the parent-side subagent view (ordered
+ * by parent Tool Call id) and `parentLinkage` is the child-side view. They default to
+ * empty/absent at construction so pre-S2 call sites stay valid; adapters always populate them.
+ */
+declare class RecoverySnapshot extends RecoverySnapshot_base {}
+declare const AdmissionConflict_base: Schema.Class<AdmissionConflict, Schema.TaggedStruct<"AdmissionConflict", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+  readonly idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly existingInputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly attemptedInputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, import("effect/Cause").YieldableError>;
+/** The same idempotency key was admitted with different canonical input content. */
+declare class AdmissionConflict extends AdmissionConflict_base {}
+declare const OwnershipLost_base: Schema.Class<OwnershipLost, Schema.TaggedStruct<"OwnershipLost", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly actualEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The presented ownership token no longer owns the Submission's lane. `actualEpoch` is the
+ * thread's current producer epoch so a stale Attempt can prove to itself it was superseded.
+ */
+declare class OwnershipLost extends OwnershipLost_base {}
+declare const SettlementConflict_base: Schema.Class<SettlementConflict, Schema.TaggedStruct<"SettlementConflict", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly existingOutcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A conflicting terminal outcome was already reserved or finalized (DUR-002, DUR-012). */
+declare class SettlementConflict extends SettlementConflict_base {}
+declare const ApprovalConflict_base: Schema.Class<ApprovalConflict, Schema.TaggedStruct<"ApprovalConflict", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly existingDecision: Schema.Literals<readonly ["approved", "denied"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A divergent approval re-decision for an already-decided `(submissionId, toolCallId)` pair.
+ * Repeating the SAME decision replays the recorded intent instead (idempotency).
+ */
+declare class ApprovalConflict extends ApprovalConflict_base {}
+declare const UnknownResolutionConflict_base: Schema.Class<UnknownResolutionConflict, Schema.TaggedStruct<"UnknownResolutionConflict", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A divergent unknown-outcome re-resolution for an already-resolved `(submissionId, toolCallId)`
+ * pair (DUR-017). Repeating the SAME resolution replays the recorded intent instead.
+ */
+declare class UnknownResolutionConflict extends UnknownResolutionConflict_base {}
+declare const ChildReservationConflict_base: Schema.Class<ChildReservationConflict, Schema.TaggedStruct<"ChildReservationConflict", {
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+  readonly status: Schema.Literals<readonly ["reserved", "releasePending", "released"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A child budget reservation request contradicts recorded reservation state: a divergent
+ * allocation for the same reservation id, a second reservation id for the same parent Tool
+ * Call, a divergent child attachment, a divergent accounting freeze, or an out-of-order state
+ * transition. `status` reports the existing row's status. Identical replays never conflict.
+ */
+declare class ChildReservationConflict extends ChildReservationConflict_base {}
+declare const LedgerError_base: Schema.Class<LedgerError, Schema.TaggedStruct<"LedgerError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Adapter-level ledger failure (storage unavailable, unknown submission, corrupt row, ...). */
+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 markReady: (request: MarkReadyRequest) => Effect.Effect<void, LedgerError>;
+  readonly lookup: (request: SubmissionLookup) => Effect.Effect<Option.Option<SubmissionSnapshot>, LedgerError>;
+  readonly resolveAdmission: (request: SubmissionLookupByKey) => Effect.Effect<AdmissionResolution, LedgerError>;
+  readonly claim: (request: ClaimRequest) => Effect.Effect<Option.Option<Claim>, LedgerError>;
+  readonly renewOwnership: (request: RenewOwnershipRequest) => Effect.Effect<OwnershipRenewal, OwnershipLost | LedgerError>;
+  readonly releaseOwnership: (request: ReleaseOwnershipRequest) => Effect.Effect<void, OwnershipLost | LedgerError>;
+  readonly markInputApplied: (request: MarkInputAppliedRequest) => Effect.Effect<void, OwnershipLost | LedgerError>;
+  readonly reserveSettlement: (request: SettlementReservation) => Effect.Effect<ReservedSettlement, SettlementConflict | OwnershipLost | LedgerError>;
+  readonly finalizeSettlement: (request: SettlementFinalization) => Effect.Effect<Settlement, SettlementConflict | LedgerError>;
+  readonly requestAbort: (request: AbortCommand) => Effect.Effect<AbortIntent, SettlementConflict | JoinedToHost | LedgerError>;
+  /**
+   * Strongly consistent lane-local read. Unknown Submissions fail with LedgerError. Canonical
+   * proof has the same meaning as in RecoverySnapshot; this read grants no execution authority.
+   */
+  readonly readAbortIntent: (request: AbortIntentRequest) => Effect.Effect<AbortIntent | undefined, LedgerError>;
+  readonly claimJoining: (request: ClaimJoiningRequest) => Effect.Effect<ReadonlyArray<JoiningClaim>, OwnershipLost | LedgerError>;
+  readonly markJoined: (request: MarkJoinedRequest) => Effect.Effect<void, OwnershipLost | LedgerError>;
+  readonly revertJoining: (request: RevertJoiningRequest) => Effect.Effect<void, LedgerError>;
+  readonly suspend: (request: SuspendRequest) => Effect.Effect<SuspensionOutcome, OwnershipLost | SettlementConflict | LedgerError>;
+  readonly recordApprovalDecision: (command: ApprovalDecisionCommand) => Effect.Effect<ApprovalDecisionIntent, ApprovalConflict | SettlementConflict | LedgerError>;
+  readonly markUnknown: (request: MarkUnknownRequest) => Effect.Effect<void, SettlementConflict | LedgerError>;
+  readonly recordUnknownResolution: (command: UnknownResolutionCommand) => Effect.Effect<UnknownResolutionIntent, UnknownResolutionConflict | SettlementConflict | LedgerError>;
+  readonly recordChildSettled: (request: ChildSettledNotification) => Effect.Effect<ChildSettledOutcome, LedgerError>;
+  readonly reserveChildBudget: (request: ChildBudgetReservationRequest) => Effect.Effect<ReservedChildBudget, ChildReservationConflict | OwnershipLost | LedgerError>;
+  readonly attachChildToReservation: (request: AttachChildToReservationRequest) => Effect.Effect<ChildBudgetReservationSnapshot, ChildReservationConflict | OwnershipLost | LedgerError>;
+  readonly beginChildBudgetRelease: (request: BeginChildBudgetReleaseRequest) => Effect.Effect<ChildBudgetReservationSnapshot, ChildReservationConflict | LedgerError>;
+  readonly releaseChildBudget: (request: ReleaseChildBudgetRequest) => Effect.Effect<ChildBudgetReservationSnapshot, ChildReservationConflict | LedgerError>;
+  readonly scanNonterminal: Stream.Stream<SubmissionSnapshot, LedgerError>;
+  readonly loadRecoverySnapshot: (request: RecoverySnapshotRequest) => Effect.Effect<RecoverySnapshot, LedgerError>;
+}>;
+/**
+ * Operational durable state for accepted work: admission, FIFO readiness, ownership, leases,
+ * abort intent, and settlement obligations (STORE-001). The Thread Log remains the
+ * authority for applied input and terminal outcomes; every marker in this ledger can be rebuilt
+ * from canonical history (DUR-015).
+ *
+ * Operation contracts:
+ *
+ * - `admit` — atomic and idempotent by (threadId, principal, idempotencyKey). A replay
+ *   with the same `inputDigest` returns the original `AdmissionResult` with `replayed` set; a
+ *   replay with a different digest fails with `AdmissionConflict`. Admission allocates the
+ *   Submission's `queueSequence` (FIFO position, DUR-004) and mints `submissionId`/`receiptId`.
+ *   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.
+ * - `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`
+ *   permits an admission attempt. Single strongly consistent stores derive the answer from a
+ *   direct lookup and never answer `Indeterminate`.
+ * - `markReady` — idempotent transition admitted → ready after Thread materialization.
+ *   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
+ *   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
+ *   claimable; expiry alone never revokes correctness, only permission to assume liveness.
+ * - `renewOwnership` — extends the lease while the token still owns the lane; fails with
+ *   `OwnershipLost` once superseded. Renewal after lease expiry succeeds if no other claim has
+ *   taken the lane in between.
+ * - `releaseOwnership` — graceful drain: ends the ownership period without settling, returning
+ *   a nonterminal head to claimable state. Fails with `OwnershipLost` once superseded.
+ * - `markInputApplied` — idempotent marker that the deterministic `UserInputRecorded` record is
+ *   canonical (state → input-applied). Recovery repairs this marker from history when the append
+ *   committed but the marker write was lost.
+ * - `reserveSettlement` — reserves the Submission's single exact settlement record
+ *   (state → terminalizing). Idempotent: an identical reservation replays with `replayed` set; a
+ *   different outcome or content fails with `SettlementConflict{existingOutcome}` (DUR-011).
+ *   For a `joined` Submission the reservation is authorized by its recorded host linkage — a
+ *   joined lane is never worker-claimable, so no ownership token can exist for it and the
+ *   presented token is not consulted (plan §2.5: joined Submissions settle with the host).
+ *   Likewise, an ABORTED reservation for a `ready`/`terminalizing` Submission that carries a
+ *   durable abort intent and holds no live ownership is authorized by that intent (P7 §7(c)):
+ *   recovery settles aborted never-claimed queued work immediately, without waiting for it to
+ *   head the lane. Both exceptions are outcome- and state-narrow; everything else stays fenced.
+ * - `finalizeSettlement` — idempotent terminal transition (state → settled) after the reserved
+ *   record is canonical; releases the lane so the next `queueSequence` becomes claimable. It
+ *   requires no ownership token: canonical history authorizes finalization (DUR-015). A
+ *   finalization that disagrees with the recorded outcome fails with `SettlementConflict`.
+ * - `requestAbort` — durable, idempotent by `submissionId`: repeating returns the recorded
+ *   intent unchanged (DUR-012). Fails with `SettlementConflict` once the Submission is settled;
+ *   abort never rewrites a terminal outcome. Fails with `JoinedToHost` for a `joined` Submission
+ *   — it settles with its host, so the abort target is the host (plan §2.5). Abort of a
+ *   `joining` Submission records the intent; it is honored only if the host has not consumed the
+ *   input (revert-then-abort).
+ * - `claimJoining` — atomic: transitions the contiguous `ready` prefix of strictly-later
+ *   `queueSequence`s (up to `maxCount`) to `joining` under the host's ownership token, recording
+ *   the host linkage; no epoch bump (the host Attempt already owns the lane). An
+ *   `admitted`-not-`ready` row breaks the prefix; an aborted-settled row is a closed obligation
+ *   and is skipped as a non-gap (P7 §7(c)). Fails with `OwnershipLost` once superseded.
+ * - `markJoined` — idempotent `joining → joined` with the canonical input record position;
+ *   repairable from history when the append committed but the marker write was lost (DUR-016).
+ * - `revertJoining` — recovery-only, idempotent `joining → ready`; a no-op when already joined.
+ * - `suspend` — `input-applied`/`running` → `suspended`; ends the ownership period WITHOUT
+ *   settling (the obligation stays owed, the lane consumes no worker permit). Returns
+ *   `resume-immediately` when the reason is already fully covered: for `ApprovalPending`,
+ *   recorded decisions cover every pending call; for `WaitingForChild`, every listed child is
+ *   already provably settled. Adapters must guarantee that a child settlement reported before
+ *   the suspend transaction commits is observed by that suspend (single-store adapters derive
+ *   this from the child's own row; cross-store adapters record a durable notification marker).
+ *   Fails with `SettlementConflict` once settled.
+ * - `recordApprovalDecision` — durable, idempotent per `(submissionId, toolCallId)`: repeating
+ *   the same decision replays the intent; a divergent re-decision fails with `ApprovalConflict`.
+ *   Transitions `suspended(ApprovalPending) → input-applied` once every pending call of the
+ *   suspension reason is decided, waking the lane. Fails with `SettlementConflict` once settled.
+ * - `recordChildSettled` — idempotent cross-lane wake (spec §12 step 10): transitions
+ *   `suspended(WaitingForChild) → input-applied` exactly when EVERY listed child is settled,
+ *   answering `woken`; `still-waiting` while any listed child is unsettled; `not-waiting` when
+ *   the parent is not suspended waiting on this child (including replays after the wake). The
+ *   child's canonical Settlement is the authority. The runtime reports it after the exact
+ *   reserved record is appended and before ledger finalization, so same-store adapters accept
+ *   `terminalizing` only when its exact reservation exists; an earlier child is an
+ *   adapter-checked caller error. It never settles the parent and requires no ownership token:
+ *   the canonically recorded child settlement authorizes the wake.
+ * - `reserveChildBudget` — idempotent get-or-create of the parent-owned child budget
+ *   reservation (spec §12 step 2), fenced by the parent lane's live `OwnershipToken`. An
+ *   identical replay returns the stored row with `replayed` set (unfenced, mirroring
+ *   `reserveSettlement`); a divergent allocation for the same id, or a second id for the same
+ *   `(parentSubmissionId, parentToolCallId)`, fails with `ChildReservationConflict`.
+ * - `attachChildToReservation` — idempotent: records the admitted child on the reservation row
+ *   (repairable from the canonical `SubagentStarted` record). A replay with the recorded child
+ *   is a no-op; the first attach is fenced by the parent token and requires status `reserved`;
+ *   a divergent child fails with `ChildReservationConflict`.
+ * - `beginChildBudgetRelease` — `reserved → releasePending`: freezes the final accounting
+ *   decision exactly once. Replaying the identical accounting (at `releasePending` or
+ *   `released`) is a no-op; a divergent accounting fails with `ChildReservationConflict`.
+ *   Requires no ownership token: the accounting is replayed from the canonical `SubagentJoined`
+ *   record (or is the deterministic zero-consumed decision for an orphaned reservation), so
+ *   canonical history authorizes the transition (DUR-015) and the freeze comparison — not a
+ *   fence — guarantees one decision.
+ * - `releaseChildBudget` — `releasePending → released`, applied exactly once; replaying returns
+ *   the released row unchanged. Releasing a still-`reserved` row (no frozen accounting) fails
+ *   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.
+ * - `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
+ *   `SettlementConflict` once settled.
+ * - `scanNonterminal` — streams every Submission whose state is not `settled`, ordered by
+ *   (threadId, queueSequence); recovery's admission-independent worklist (DUR-014).
+ * - `loadRecoverySnapshot` — strongly consistent full snapshot for the pure recovery classifier.
+ *
+ * No operation claims exactly-once external side effects; the ledger records decisions
+ * exactly once (DUR-003).
+ */
+declare class SubmissionLedger extends SubmissionLedger_base {}
+/**
+ * Deterministic identity rules shared by every adapter and the durable coordinator. The batch
+ * carrying one Submission's canonical `UserInputRecorded` record is `submission-input:{sid}` and
+ * the record is `input:{sid}`, so batch idempotency (DUR-007) makes the input append
+ * exactly-once-canonical across Attempts.
+ */
+declare const submissionInputBatchId: (submissionId: SubmissionId) => BatchId;
+/** Deterministic canonical record identity of one Submission's `UserInputRecorded` record. */
+declare const submissionInputRecordId: (submissionId: SubmissionId) => RecordId;
+/** Deterministic `SettlementId` for one Submission: `settlement:{sid}`. */
+declare const submissionSettlementId: (submissionId: SubmissionId) => SettlementId;
+/** Deterministic batch identity of one Submission's canonical `SubmissionSettled` append. */
+declare const submissionSettlementBatchId: (submissionId: SubmissionId) => BatchId;
+/** Deterministic canonical record identity of one Submission's `SubmissionSettled` record. */
+declare const submissionSettlementRecordId: (submissionId: SubmissionId) => RecordId;
+/** Deterministic batch identity of one Submission's canonical `AbortRequested` append. */
+declare const submissionAbortBatchId: (submissionId: SubmissionId) => BatchId;
+/** Deterministic canonical record identity of one Submission's `AbortRequested` record. */
+declare const submissionAbortRecordId: (submissionId: SubmissionId) => RecordId;
+/** Destination policy, captured when the ledger is acquired. It runs inside fresh admission's
+ * serialization after replay lookup. The host must keep it bounded and must not reenter admit.
+ * The callback must read authoritative policy in this SAME local transaction, through the
+ * acquired SqlClient. Memory evaluates the callback synchronously inside its atomic mutation;
+ * an async callback fails with `unavailable/synchronous-memory-policy-required`. Remote reads do not fence remote changes.
+ * All policy writers must use that transaction owner. Do not fork, reenter admission, or retain
+ * transaction resources. Failure/defect/interruption commits no fresh admission.
+ * Current policy never invalidates an exact retained receipt. A supplied fence fails closed
+ * unless the destination installed an interpreter for it. */
+declare const SubmissionAdmissionFence: Context.Reference<{
+  readonly check: (request: AdmissionRequest) => Effect.Effect<void, AdmissionPolicyError>;
+}>;
+declare namespace Recovery_d_exports {
+  export { AppendReservedSettlement, ApplyInput, ApplyJoinAccounting, ApplyUnknownResolutions, AwaitApprovalDecision, AwaitChildAdmissionResolution, AwaitChildSettlement, AwaitHostSettlement, AwaitParentEstablishment, AwaitUnknownResolution, CompleteChildAdmission, CompleteMaterialization, DeclaredPendingBatchEvidence, DelegationAdmissionEvidence, EnsureWaitingForChild, FinalizeLedgerFromHistory, MarkUnknown, NoAction, OpenDelegationCallEvidence, OpenToolCallEvidence, PendingApprovalEvidence, PropagateChildAbort, RecoveryDecision, RecoveryEvidence, ReleaseOrphanChildReservation, RepairInputMarker, RepairJoinMarker, RepairReadiness, RepairSubagentStartLink, ResumeFromTurnBoundary, ResumePendingToolBatch, ResumeSuspended, ResumeWaitingParent, RevertJoining, SettleAborted, SettleJoinedWithHost, classifyRecovery };
+}
+declare const OpenToolCallEvidence_base: Schema.Class<OpenToolCallEvidence, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly turn: Schema.Int;
+}>, {}>;
+/** One canonical `ToolCallPrepared` without a settling or resolving canonical record (DUR-009). */
+declare class OpenToolCallEvidence extends OpenToolCallEvidence_base {}
+declare const DeclaredPendingBatchEvidence_base: Schema.Class<DeclaredPendingBatchEvidence, Schema.Struct<{
+  readonly turn: Schema.Int;
+  readonly callCount: Schema.Int;
+}>, {}>;
+/**
+ * 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.
+ */
+declare class DeclaredPendingBatchEvidence extends DeclaredPendingBatchEvidence_base {}
+declare const PendingApprovalEvidence_base: Schema.Class<PendingApprovalEvidence, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly turn: Schema.Int;
+}>, {}>;
+/** One canonical `ToolApprovalRequested` without a canonical `ToolApprovalDecided`. */
+declare class PendingApprovalEvidence extends PendingApprovalEvidence_base {}
+/**
+ * The authoritative tri-state admission answer recorded as pure classifier evidence (SUB-031):
+ * the recovery pass queries `resolveAdmission` with the deterministic child idempotency key for
+ * a requested-but-unstarted delegation call and records the result here. Absence of this field
+ * means the lookup was not performed — the classifier treats that exactly like `indeterminate`
+ * (fail-closed: only a proven `not-admitted` ever permits an admission attempt).
+ */
+declare const DelegationAdmissionEvidence: Schema.Literals<readonly ["not-admitted", "admitted", "indeterminate"]>;
+type DelegationAdmissionEvidence = typeof DelegationAdmissionEvidence.Type;
+declare const OpenDelegationCallEvidence_base: Schema.Class<OpenDelegationCallEvidence, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly turn: Schema.Int;
+  /** The canonical `SubagentRequested` record exists for this call. */
+  readonly requested: Schema.Boolean;
+  /** The canonical `SubagentStarted` record exists for this call. */
+  readonly started: Schema.Boolean;
+  /** The canonical `SubagentJoined` record exists for this call. */
+  readonly joined: Schema.Boolean;
+  readonly childThreadId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+  readonly childSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly admission: Schema.optionalKey<Schema.Literals<readonly ["not-admitted", "admitted", "indeterminate"]>>;
+}>, {}>;
+/**
+ * One prepared-without-outcome parent Tool Call that IS a delegation (plan §4.1), separated from
+ * `openToolCalls` because its establishment protocol is idempotent by construction and must
+ * NEVER be marked Unknown (spec §13 vs. DUR-009). Delegation detection is durable and
+ * fail-closed: canonical preparation records carry the definition-owned execution kind;
+ * child reservations and request records must agree with that classification. Names never
+ * authorize replay, including in the pre-reservation window. The
+ * `requested`/`started`/`joined` flags come from the parent-log canonical records; the child
+ * identity fields are present exactly when those records (or the reservation attachment) carry
+ * them.
+ */
+declare class OpenDelegationCallEvidence extends OpenDelegationCallEvidence_base {}
+declare const RecoveryEvidence_base: Schema.Class<RecoveryEvidence, Schema.Struct<{
+  /** The Thread exists in the ThreadStore. */
+  readonly threadMaterialized: Schema.Boolean;
+  /** The deterministic canonical `UserInputRecorded` record (`input:{sid}`) is committed. */
+  readonly inputRecorded: Schema.Boolean;
+  /**
+   * The committed canonical `SubmissionSettled` outcome (`settlement:{sid}`). Present exactly
+   * when the canonical settlement record exists, so the flag and the outcome cannot diverge.
+   */
+  readonly recordedSettlementOutcome: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+  /** The deterministic canonical `AbortRequested` record (`abort:{sid}`) is committed. */
+  readonly abortRecorded: Schema.Boolean;
+  /** Prepared ordinary Tool Calls without a canonical settled/resolved outcome (DUR-009). */
+  readonly openToolCalls: Schema.$Array<typeof OpenToolCallEvidence>;
+  /**
+   * Delegation Tool Calls with an open parent-side obligation (plan §4.1), removed from
+   * `openToolCalls`. Wire-required; construction alone defaults it so pre-S2 evidence
+   * assemblers stay valid while the classifier's fail-closed detection still protects them.
+   */
+  readonly openDelegationCalls: Schema.withConstructorDefault<Schema.$Array<typeof OpenDelegationCallEvidence>>;
+  /** Only persisted orchestration classification authorizes idempotent host-operation replay. */
+  readonly openWorkerCalls: Schema.optionalKey<Schema.$Array<typeof OpenToolCallEvidence>>;
+  /** A declared-but-unprepared tool batch: response canonical, zero prepared, zero settled. */
+  readonly declaredPendingBatch: Schema.optionalKey<typeof DeclaredPendingBatchEvidence>;
+  /** Canonically requested approvals without a canonical decision. */
+  readonly approvalsPending: Schema.$Array<typeof PendingApprovalEvidence>;
+  /** Joined-side prompt coverage (plan §2.5); `true` whenever the Submission is not joined. */
+  readonly joinedInputCovered: Schema.Boolean;
+  /** Joined-side view of the host's canonical settlement record, when it exists. */
+  readonly hostSettlementOutcome: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+  /**
+   * The Thread carries its canonical `SubagentLineageRecorded` record. Only
+   * consulted for a parent-linked Submission: a child whose lineage is not yet canonical defers
+   * its own materialization/readiness repair to the parent's idempotent establishment
+   * (`AwaitParentEstablishment`). Defaults to `false` so an assembler that does not compute it
+   * stays fail-closed: deferring is safe because the parent's establishment completes the child;
+   * running a Turn before lineage is recorded would violate the child establishment ordering.
+   */
+  readonly subagentLineageRecorded: Schema.withConstructorDefault<Schema.Boolean>;
+}>, {}>;
+/**
+ * Canonical-log facts about one Submission, read strongly consistently alongside the ledger
+ * `RecoverySnapshot` (STORE-003). Canonical history wins over every ledger marker (DUR-015), so
+ * the classifier consults these facts before trusting ledger state — with one deliberate Phase 5
+ * inversion: a RECORDED terminal outcome now beats open tool calls, because a canonical
+ * settlement is never revisited (DUR-002/DUR-015); the P4 rule that unknown-beats-settlement is
+ * gone.
+ *
+ * `openToolCalls` is the DUR-009 seam: every `ToolCallPrepared` without a matching
+ * `ToolCallSettled` or `ToolCallResolved`. S2 separates `openDelegationCalls` from it (plan
+ * §4.1): a delegation's prepared-without-outcome state is provably replay-safe, so those calls
+ * route through the Subagent recovery rows and never through `MarkUnknown`. Names and
+ * operational reservation rows cannot upgrade ordinary classification. `joinedInputCovered`
+ * implements the plan §2.5 prompt-coverage rule for the joined side: a joined input is covered
+ * iff a later `ModelResponseRecorded` of the host Run exists after the `input:{sid}` record.
+ * `hostSettlementOutcome` is the joined-side view of the host's canonical `SubmissionSettled`
+ * record, present exactly when that record exists.
+ */
+declare class RecoveryEvidence extends RecoveryEvidence_base {}
+declare const CompleteMaterialization_base: Schema.Class<CompleteMaterialization, Schema.TaggedStruct<"CompleteMaterialization", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Ledger admission committed but the Thread is not durable: finish materialization,
+ * append `ThreadCreated`, and mark readiness (crash between admit and materialize). */
+declare class CompleteMaterialization extends CompleteMaterialization_base {}
+declare const RepairReadiness_base: Schema.Class<RepairReadiness, Schema.TaggedStruct<"RepairReadiness", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Thread durable but the readiness marker is missing: idempotent `markReady`. */
+declare class RepairReadiness extends RepairReadiness_base {}
+declare const ApplyInput_base: Schema.Class<ApplyInput, Schema.TaggedStruct<"ApplyInput", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** No canonical input yet: append the deterministic `UserInputRecorded` record and mark it. */
+declare class ApplyInput extends ApplyInput_base {}
+declare const RepairInputMarker_base: Schema.Class<RepairInputMarker, Schema.TaggedStruct<"RepairInputMarker", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Canonical input exists but the ledger marker was lost: repair the marker only (DUR-015). */
+declare class RepairInputMarker extends RepairInputMarker_base {}
+declare const ResumeFromTurnBoundary_base: Schema.Class<ResumeFromTurnBoundary, Schema.TaggedStruct<"ResumeFromTurnBoundary", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Input applied and no terminal work reserved: a worker resumes the Run from the last committed
+ * Turn boundary (D6; the model may be re-invoked, duplicate cost is observable — the resuming
+ * worker appends `ModelResponseInterrupted` when superseding a prior owner, durability §9). */
+declare class ResumeFromTurnBoundary extends ResumeFromTurnBoundary_base {}
+declare const AppendReservedSettlement_base: Schema.Class<AppendReservedSettlement, Schema.TaggedStruct<"AppendReservedSettlement", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+}>, {}>;
+/** A settlement is reserved but not canonical: append the EXACT reserved record, then finalize. */
+declare class AppendReservedSettlement extends AppendReservedSettlement_base {}
+declare const FinalizeLedgerFromHistory_base: Schema.Class<FinalizeLedgerFromHistory, Schema.TaggedStruct<"FinalizeLedgerFromHistory", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+}>, {}>;
+/** The canonical settlement record exists: rebuild/finalize the ledger from history and never
+ * rewrite history from the cached ledger status (DUR-011, DUR-015). */
+declare class FinalizeLedgerFromHistory extends FinalizeLedgerFromHistory_base {}
+declare const SettleAborted_base: Schema.Class<SettleAborted, Schema.TaggedStruct<"SettleAborted", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** A durable abort intent exists, no terminal outcome is reserved, and no attached-child
+ * obligation remains open: settle aborted (DUR-012). The executor first appends
+ * `ToolCallUnknown` audit records for any open ordinary calls — abort settles the obligation but
+ * never asserts external rollback (durability §13). */
+declare class SettleAborted extends SettleAborted_base {}
+declare const MarkUnknown_base: Schema.Class<MarkUnknown, Schema.TaggedStruct<"MarkUnknown", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly reason: Schema.String;
+  readonly openToolCallIds: Schema.$Array<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">>;
+}>, {}>;
+/** Prepared ordinary Tool Calls have no canonical outcome: the executor reconciles each open
+ * call (recovered result / never-started / safe-retry) and marks the remainder Unknown — never
+ * an automatic replay (DUR-009/DUR-017). Delegation calls are excluded: their establishment is
+ * idempotent by construction and routes through the Subagent rows instead (plan §4.3). */
+declare class MarkUnknown extends MarkUnknown_base {}
+declare const ResumePendingToolBatch_base: Schema.Class<ResumePendingToolBatch, Schema.TaggedStruct<"ResumePendingToolBatch", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  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
+ * 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 {}
+declare const AwaitApprovalDecision_base: Schema.Class<AwaitApprovalDecision, Schema.TaggedStruct<"AwaitApprovalDecision", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Canonically requested approvals lack decisions: the lane waits durably (the executor repairs
+ * the ledger suspension from history when the suspend transition itself was lost). */
+declare class AwaitApprovalDecision extends AwaitApprovalDecision_base {}
+declare const ResumeSuspended_base: Schema.Class<ResumeSuspended, Schema.TaggedStruct<"ResumeSuspended", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Every pending approval has a durable decision: a worker resumes the declared batch via the
+ * batch-resume seam, appending the canonical `ToolApprovalDecided` records first. */
+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
+ * 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. */
+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">;
+}>, {}>;
+/** `joining` without a canonical `input:{sid}` record: revert to `ready` — the input was never
+ * consumed and will be delivered exactly once later (DUR-016). */
+declare class RevertJoining extends RevertJoining_base {}
+declare const RepairJoinMarker_base: Schema.Class<RepairJoinMarker, Schema.TaggedStruct<"RepairJoinMarker", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** The canonical input exists but the `joined` marker was lost: repair the marker only, exactly
+ * like `RepairInputMarker` (DUR-015/DUR-016); the input reattaches, never duplicates. */
+declare class RepairJoinMarker extends RepairJoinMarker_base {}
+declare const SettleJoinedWithHost_base: Schema.Class<SettleJoinedWithHost, Schema.TaggedStruct<"SettleJoinedWithHost", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+}>, {}>;
+/** The host Run settled canonically: settle this joined Submission with the host outcome
+ * (each joined Submission is owed its own settlement, DUR-002). */
+declare class SettleJoinedWithHost extends SettleJoinedWithHost_base {}
+declare const AwaitHostSettlement_base: Schema.Class<AwaitHostSettlement, Schema.TaggedStruct<"AwaitHostSettlement", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly hostSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+}>, {}>;
+/** The Submission is `joined` and its host Run is still live: nothing to repair — the input
+ * reattaches through the host's resume and the Submission settles with the host. */
+declare class AwaitHostSettlement extends AwaitHostSettlement_base {}
+declare const CompleteChildAdmission_base: Schema.Class<CompleteChildAdmission, Schema.TaggedStruct<"CompleteChildAdmission", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, {}>;
+/** A canonical `SubagentRequested` exists and the authoritative admission lookup proved
+ * `notAdmitted`: idempotently admit the intended child from the canonical request payload — it
+ * carries the encoded child input (D3), the intended child identity, and every digest — then
+ * materialize the child Thread, append its immutable lineage, and mark it ready. No live
+ * delegation handler is required (spec §13, SUB-016/SUB-031). */
+declare class CompleteChildAdmission extends CompleteChildAdmission_base {}
+declare const AwaitChildAdmissionResolution_base: Schema.Class<AwaitChildAdmissionResolution, Schema.TaggedStruct<"AwaitChildAdmissionResolution", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, {}>;
+/** A canonical `SubagentRequested` exists but the authoritative admission lookup answered
+ * `indeterminate` — or was not (yet) performed: wait and retry the authoritative owner directly.
+ * Absence from a projection is never proof of absence and a second admission NEVER occurs
+ * (spec §12, SUB-031). */
+declare class AwaitChildAdmissionResolution extends AwaitChildAdmissionResolution_base {}
+declare const RepairSubagentStartLink_base: Schema.Class<RepairSubagentStartLink, Schema.TaggedStruct<"RepairSubagentStartLink", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, {}>;
+/** The child Submission is admitted but the parent's `SubagentStarted` link is missing (or its
+ * reservation attachment was lost): resolve the SAME child by its deterministic idempotency key
+ * and append the exact deterministic start record, then attach the child to its reservation —
+ * the same Receipt on every replay (spec §13, SUB-016/SUB-017). */
+declare class RepairSubagentStartLink extends RepairSubagentStartLink_base {}
+declare const EnsureWaitingForChild_base: Schema.Class<EnsureWaitingForChild, Schema.TaggedStruct<"EnsureWaitingForChild", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly children: Schema.NonEmptyArray<typeof WaitingChild>;
+}>, {}>;
+/** Children are established and at least one is nonterminal while the parent lane is NOT
+ * durably suspended: restore the `waitingForChild` suspension so the lane holds no worker
+ * permit while each child runs on its own lane. Recovery reattaches the one existing child and
+ * NEVER spawns a replacement (spec §13, SUB-018/SUB-030). */
+declare class EnsureWaitingForChild extends EnsureWaitingForChild_base {}
+declare const AwaitChildSettlement_base: Schema.Class<AwaitChildSettlement, Schema.TaggedStruct<"AwaitChildSettlement", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** The parent is durably suspended `WaitingForChild` and at least one listed child is not yet
+ * provably settled: the lane stays dormant and consumes no permit; the child's Settlement wakes
+ * it durably (spec §12 step 10). An unresolved ordinary Tool inside a child keeps the parent
+ * here honestly — the obligation stays visible and aged, nothing is fabricated (SUB-021). */
+declare class AwaitChildSettlement extends AwaitChildSettlement_base {}
+declare const ResumeWaitingParent_base: Schema.Class<ResumeWaitingParent, Schema.TaggedStruct<"ResumeWaitingParent", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly children: Schema.NonEmptyArray<typeof WaitingChild>;
+}>, {}>;
+/** Every relevant child is provably settled but the parent has not joined (legacy data, or a
+ * canonical settlement whose idempotent wake still needs replay): record/replay the durable wake
+ * so a claiming worker resumes the declared batch and joins each child's canonical Settlement —
+ * the join itself needs the parent Binding and is deferred to that worker (spec §13). */
+declare class ResumeWaitingParent extends ResumeWaitingParent_base {}
+declare const ApplyJoinAccounting_base: Schema.Class<ApplyJoinAccounting, Schema.TaggedStruct<"ApplyJoinAccounting", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly reservationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">;
+}>, {}>;
+/** The canonical `SubagentJoined` record exists but the reservation release is incomplete:
+ * replay `beginChildBudgetRelease` with the accounting decision FROM the canonical record, then
+ * apply `releaseChildBudget` — budget stays unavailable until repair, never available twice
+ * (spec §12 join step 6, DUR-015). */
+declare class ApplyJoinAccounting extends ApplyJoinAccounting_base {}
+declare const PropagateChildAbort_base: Schema.Class<PropagateChildAbort, Schema.TaggedStruct<"PropagateChildAbort", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly children: Schema.NonEmptyArray<typeof WaitingChild>;
+}>, {}>;
+/** Parent abort is canonical while attached children are nonterminal: idempotently issue each
+ * child's durable abort command and keep the parent waiting for the joins —
+ * request-abort-and-join is the ONLY close behavior; the replayed command returns the recorded
+ * child intent unchanged, so the intent row IS the propagation marker (spec §13.1, SUB-022,
+ * DUR-012). */
+declare class PropagateChildAbort extends PropagateChildAbort_base {}
+declare const ReleaseOrphanChildReservation_base: Schema.Class<ReleaseOrphanChildReservation, Schema.TaggedStruct<"ReleaseOrphanChildReservation", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly reservationIds: Schema.NonEmptyArray<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ChildReservationId">>;
+}>, {}>;
+/** A child budget reservation can no longer bind a child — its request is absent with no
+ * resumable batch, or the parent is aborting and the child provably never admitted: freeze the
+ * deterministic zero-consumed accounting decision and release the unused allocation exactly
+ * once (spec §13/§14: "releases the reservation exactly once"). */
+declare class ReleaseOrphanChildReservation extends ReleaseOrphanChildReservation_base {}
+declare const AwaitParentEstablishment_base: Schema.Class<AwaitParentEstablishment, Schema.TaggedStruct<"AwaitParentEstablishment", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly parentSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly parentToolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, {}>;
+/**
+ * A parent-linked `admitted` Submission whose Thread lacks the canonical
+ * `SubagentLineageRecorded` record: the child lane DEFERS its own materialization/readiness
+ * repair — the parent's idempotent establishment (admit → materialize → lineage → ready)
+ * completes it, so a child never runs a Turn before its lineage record is canonical.
+ * This preserves the child establishment ordering. It is ordering/liveness hygiene, not a
+ * safety repair — the join already fails closed without lineage (SUB-019).
+ */
+declare class AwaitParentEstablishment extends AwaitParentEstablishment_base {}
+declare const NoAction_base: Schema.Class<NoAction, Schema.TaggedStruct<"NoAction", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** The Submission is settled; nothing is owed. */
+declare class NoAction extends NoAction_base {}
+/** The executable recovery decision table's output alphabet (plan §Recovery classifier). */
+declare const RecoveryDecision: 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]>;
+type RecoveryDecision = typeof RecoveryDecision.Type;
+/**
+ * Pure recovery classifier (durability §14, DUR-013): a finite persisted snapshot plus canonical
+ * evidence deterministically selects exactly one decision. Precedence, most-settled first
+ * (plan §4.2/§4.3 — note the deliberate P5 reorder: canonical settlement and reservation beat
+ * open tool calls, because a recorded terminal outcome is never revisited, DUR-002/DUR-015; and
+ * the three S2 edits: the abort row propagates to nonterminal attached children, delegation
+ * calls never mark Unknown, and the suspended row branches on the suspension reason):
+ *
+ * 1. `settled` → NoAction — terminal outcomes are never revisited (DUR-002).
+ * 2. canonical settlement record → FinalizeLedgerFromHistory — history beats every ledger
+ *    marker (DUR-015), including a missing or divergent reservation AND open tool calls.
+ * 3. reservation → FinalizeLedgerFromHistory when finalized, else AppendReservedSettlement —
+ *    the reserved record is the single exact outcome owed (DUR-011); it also beats a pending
+ *    abort intent (DUR-012).
+ * 4. joined-side states (DUR-016): `joining` without canonical input → RevertJoining; `joining`
+ *    with canonical input → RepairJoinMarker (marker lost); `joined` + host settled →
+ *    SettleJoinedWithHost; `joined` + host live → AwaitHostSettlement (deferred).
+ * 5. abort intent → the S2 abort rows (spec §13.1 request-abort-and-join): an unproven child
+ *    admission waits, an admitted-but-unlinked child repairs its start link, a nonterminal
+ *    attached child gets PropagateChildAbort — the parent does NOT settle — terminal children
+ *    are joined, incomplete releases applied, provably childless reservations released; ONLY a
+ *    parent with no open child obligation reaches SettleAborted, where open ordinary calls
+ *    become `ToolCallUnknown` audit records, never a rollback claim (§13). SettleAborted is
+ *    position-blind by design (P7 §7(c)): an aborted, never-claimed `ready` Submission earns it
+ *    ANYWHERE in the queue — the executor settles it immediately without waiting for it to head
+ *    the lane, because settlement order of never-run work is not execution order (DUR-004
+ *    bounds execution order; DUR-012 permits settling inactive accepted work without an
+ *    Attempt).
+ * 6. ordinary open tool calls (state not yet `unknown`) → MarkUnknown — reconcile-then-mark,
+ *    never an automatic replay (DUR-009). Delegation calls are EXCLUDED (plan §4.3's most
+ *    important edit): their prepared-without-outcome state is provably replay-safe and routes
+ *    through rows 5/8/9 instead. A lane already `unknown` is in the DUR-017 resolution regime
+ *    (row 7) and is not re-marked.
+ * 7. state `unknown` → ApplyUnknownResolutions when durable intents cover every open ordinary
+ *    call, else AwaitUnknownResolution.
+ * 8. state `suspended` branches on the stored reason: `WaitingForChild` → ResumeWaitingParent
+ *    when every listed child is provably settled (replay the idempotent wake), else
+ *    AwaitChildSettlement (SUB-030); `ApprovalPending` keeps the P5 behavior — undecided
+ *    canonical approval requests → AwaitApprovalDecision (repairing a lost suspend transition
+ *    from history), every request decided → ResumeSuspended.
+ * 9. the S2 establishment/join rows for a live parent (spec §13, most-repairing first):
+ *    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).
+ * 11. `admitted` → a parent-linked Submission whose Thread lacks the canonical lineage
+ *     record defers (AwaitParentEstablishment: the parent's idempotent establishment
+ *     completes it); otherwise
+ *     CompleteMaterialization / RepairReadiness by Thread durability.
+ * 12. otherwise → ApplyInput / RepairInputMarker / ResumeFromTurnBoundary by canonical input
+ *     evidence, with the ledger marker repaired from history, never the reverse.
+ *
+ * A CHILD Submission (one whose snapshot carries `parentLinkage`) classifies through exactly
+ * the same rows as any Submission — child recovery proceeds under its own ownership token and
+ * epoch (spec §13, SUB-020); nothing here consults the parent's lane.
+ *
+ * Ownership leases are deliberately ignored here: the executor's fenced claim is the only
+ * authority over liveness, and a stale Attempt is fenced by producer epoch regardless (DUR-006).
+ */
+declare const classifyRecovery: (snapshot: RecoverySnapshot, evidence: RecoveryEvidence) => RecoveryDecision;
+declare namespace Digest_d_exports {
+  export { DigestError, EMPTY_TAIL_DIGEST, digestCanonicalBatch, digestDefinition, digestDefinitions, digestJson };
+}
+declare const DigestError_base: Schema.Class<DigestError, Schema.TaggedStruct<"DigestError", {
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+declare class DigestError extends DigestError_base {}
+/** Digest a JSON value using a stable, locale-independent object-key ordering (UTF-16 code units, RFC 8785 style). */
+declare const digestJson: (value: Schema.Json) => Effect.Effect<string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">, DigestError, Crypto.Crypto>;
+/** Digest a canonical batch together with the prior tail to form an append-only hash chain. */
+declare const digestCanonicalBatch: (previousTailDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">, batch: CanonicalBatch) => Effect.Effect<string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">, DigestError, Crypto.Crypto>;
+/** Digest one schema-encoded Agent, Model, or Toolkit definition. */
+declare const digestDefinition: (definition: Schema.Json) => Effect.Effect<string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">, DigestError, Crypto.Crypto>;
+/** Digest all replay-relevant definitions without hiding which authority changed. */
+declare const digestDefinitions: (definitions: DefinitionDigestInput) => Effect.Effect<DefinitionDigests, DigestError, Crypto.Crypto>;
+declare const EMPTY_TAIL_DIGEST: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
+//#endregion
+//#region src/durable/internal/agent-registration.d.ts
+declare const BindingUnavailable_base: Schema.Class<BindingUnavailable, Schema.TaggedStruct<"BindingUnavailable", {
+  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.
+ */
+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 its exact stored
+ * definition/model/tool digests do not match the claimed head's stored
+ * digests byte-for-byte. Fail closed (SUB-023): missing or different code is
+ * a typed compatibility failure, never a silent substitution.
+ */
+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). */
+declare const definitionDigestsEqual: (left: DefinitionDigests, right: DefinitionDigests) => boolean;
+type ExecutableDefinition = AnyDefinition & {
+  readonly instructions: InstructionSource<never, unknown, unknown>;
+  readonly inputPrompt?: InputPromptSource<never, unknown, unknown> | undefined;
+};
+/** Executable model Binding accepted by durable registration descriptors. */
+type ExecutableAgentBinding = {
+  readonly definition: ExecutableDefinition;
+  readonly model: Layer.Layer<ModelServices, never, unknown>;
+};
+/**
+ * Internal coordinator entry point for one fenced Attempt over an already-granted claim.
+ * The generic signature matches `runAttempt` and is specialized for each captured Agent.
+ */
+type ResolvedAttemptDriver = <InputSchema extends Schema.Top, OutputSchema extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue extends RunDispositionDeclaration<OutputSchema["Type"], Schema.Top> | undefined, InputPromptValue extends InputPromptSource<InputSchema["Type"], unknown, unknown> | undefined, UpdatesSchema extends Schema.Top | undefined>(agent: RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, threadId: ThreadId, claim: Claim) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure, DurableWorkerRequirements<RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, InstructionRequirements>>;
+/**
+ * An Agent with its worker services captured, ready to drive a fenced Attempt.
+ * Concrete Schema and model types stay inside this closure when registrations are collected.
+ */
+interface CapturedBinding {
+  readonly agentId: AgentId;
+  /** Exact immutable definition whose codecs and behavior the worker captured. */
+  readonly definition: AnyDefinition;
+  /** Captured independently from per-Attempt services: report preparation has no fenced Claim. */
+  readonly reporting?: ReadonlyArray<WorkerReporting<WorkerReportPreparationFailure>>;
+  readonly attempt: (driver: ResolvedAttemptDriver, threadId: ThreadId, claim: Claim) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure>;
+}
+type ReportRequirements<Reports> = Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>> ? [Reports[number]] extends [never] ? never : Reports[number] extends WorkerReporting<unknown, infer R> ? Exclude<R, Scope.Scope> : never : never;
+/** One exact executable registration used by durable claim-time resolution. */
+interface ResolvedBinding extends CapturedBinding {
+  readonly digests: DefinitionDigests;
+}
+/** Trusted claim identity for resolving per-Attempt application services. Not model input. */
+interface AgentAttemptContext {
+  readonly threadId: ThreadId;
+  readonly submissionId: Claim["submissionId"];
+  readonly attemptId: Claim["attemptId"];
+}
+/**
+ * Build one exact worker registration from an executable Agent Binding and
+ * its already-computed definition digests.
+ *
+ * `make(agent, digests)` captures the binding plus its worker-requirement
+ * Context at Layer/effect construction time. Hosts that start from application
+ * version declarations should use `compileRegistrations`; low-level fixtures
+ * may supply a previously computed digest triple directly.
+ */
+declare const DurableWorkerBinding: {
+  readonly make: <A extends ExecutableAgentBinding, const Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>> = readonly []>(agent: A, digests: DefinitionDigests, reporting?: Reports) => Effect.Effect<ResolvedBinding, never, DurableWorkerRequirements<A> | ReportRequirements<Reports>>;
+};
+/** Application versions and a model Layer, supplied directly or through an existing Binding. */
+type AgentRegistration<A extends ExecutableAgentBinding = ExecutableAgentBinding> = ({
+  readonly agent: A;
+  readonly model?: never;
+  readonly definitions: DefinitionDigestInput;
+} | {
+  readonly agent: A["definition"];
+  readonly model: A["model"];
+  readonly definitions: DefinitionDigestInput;
+}) & {
+  /**
+   * Source-owned reports capture services outside attemptLayer and open a fresh Scope per
+   * preparation. Version changes with this registration. Missing exact code and preparation
+   * failures become retained report refusals; durable delivery retries reuse the frozen input.
+   */
+  readonly reporting?: ReadonlyArray<WorkerReporting<unknown, unknown>>;
+  /**
+   * Build fresh services for exactly one fenced Attempt, across all its Tool/model turns.
+   * Finalizes on completion, suspension, failure and interruption. Never reused after eviction.
+   * Resolve invocation authority from the trusted claim identity, not captured caller state.
+   * Keep fallible resource acquisition lazy in typed Tool operations; this Layer cannot fail.
+   */
+  readonly attemptLayer?: (context: AgentAttemptContext) => Layer.Layer<never, never, unknown>;
+};
+type EntryWorkerRequirements<Entry> = Entry extends {
+  readonly agent: infer A extends ExecutableAgentBinding;
+} ? DurableWorkerRequirements<A> : Entry extends {
+  readonly agent: infer D extends ExecutableDefinition;
+  readonly model: infer M extends ExecutableAgentBinding["model"];
+} ? DurableWorkerRequirements<{
+  readonly definition: D;
+  readonly model: M;
+}> : 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> | ("reporting" extends keyof Entry ? ReportRequirements<Entry["reporting"]> : never) : never;
+type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = [Entries[number]] extends [never] ? never : 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 {
+  export { AgentAttemptContext, AgentRegistration, BindingDigestMismatch, BindingUnavailable, DurableBindingFailure, DurableWorkerBinding, ExecutableAgentBinding, ResolvedBinding, 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 };
+}
+/**
+ * The disposition family of `RecoveryReport`, reused verbatim so an explanation predicts exactly
+ * what `runRecovery`/`retry` would report for the same decision.
+ */
+declare const RecoveryDisposition: Schema.Literals<readonly ["repaired", "deferred", "none", "unknown"]>;
+type RecoveryDisposition = typeof RecoveryDisposition.Type;
+declare const ExplainedSubmission_base: Schema.Class<ExplainedSubmission, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly state: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+  readonly queueSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/QueueSequence">;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly readyAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+  /** Whole seconds since admission (`createdAt`). */
+  readonly ageSeconds: Schema.Int;
+  /** Whole seconds since readiness, present exactly when `readyAt` is recorded. */
+  readonly readyAgeSeconds: Schema.optionalKey<Schema.Int>;
+  readonly parentLinkage: Schema.optionalKey<typeof ParentLinkage>;
+}>, {}>;
+/** Submission identity, lane position, and Clock-derived ages (DUR-017 obligation visibility). */
+declare class ExplainedSubmission extends ExplainedSubmission_base {}
+declare const ExplainedUnknownCall_base: Schema.Class<ExplainedUnknownCall, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+  readonly recordedAt: Schema.DateTimeUtcFromString;
+  /** A durable `resolveUnknown` intent covers this call. */
+  readonly resolved: Schema.Boolean;
+}>, {}>;
+/** One durable Unknown Outcome and whether a covering resolution intent exists (DUR-017). */
+declare class ExplainedUnknownCall extends ExplainedUnknownCall_base {}
+declare const ExplainedEvidence_base: Schema.Class<ExplainedEvidence, Schema.Struct<{
+  readonly threadMaterialized: Schema.Boolean;
+  readonly inputRecorded: Schema.Boolean;
+  readonly abortRecorded: Schema.Boolean;
+  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>;
+  /** Delegation Tool Calls with an open parent-side obligation. */
+  readonly openDelegationCalls: Schema.$Array<typeof OpenDelegationCallEvidence>;
+  /** Canonically requested approvals without a canonical decision. */
+  readonly approvalsPending: Schema.$Array<typeof PendingApprovalEvidence>;
+  /** Durable Unknown Outcomes with their resolution coverage (DUR-017). */
+  readonly unknownCalls: Schema.$Array<typeof ExplainedUnknownCall>;
+  /** Durable approval decisions recorded against this Submission. */
+  readonly approvalDecisions: Schema.$Array<typeof ApprovalDecisionIntent>;
+  /** Durable unknown-outcome resolutions recorded against this Submission. */
+  readonly unknownResolutions: Schema.$Array<typeof UnknownResolutionIntent>;
+  /** Parent-side child attachments. */
+  readonly childAttachments: Schema.$Array<typeof ChildAttachmentSnapshot>;
+  /** Host-side joined/joining members of this Submission's Run (DUR-016). */
+  readonly joins: Schema.$Array<typeof JoinSnapshot>;
+  /** Joined-side host identity, when this Submission is joined to a host Run. */
+  readonly hostSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly suspension: Schema.optionalKey<typeof SuspensionSnapshot>;
+  readonly abortIntent: Schema.optionalKey<typeof AbortIntent>;
+}>, {}>;
+/**
+ * The evidence summary of one explanation: the classifier's canonical-history inputs plus the
+ * durable intents and subagent attachments the ledger snapshot carries. Everything is read-only
+ * observation — assembling this value performs zero writes.
+ */
+declare class ExplainedEvidence extends ExplainedEvidence_base {}
+declare const RecoveryExplanation_base: Schema.Class<RecoveryExplanation, Schema.Struct<{
+  readonly submission: typeof ExplainedSubmission;
+  readonly evidence: typeof ExplainedEvidence;
+  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]>;
+  /** Static operator meaning of `decision._tag` (see `RECOVERY_DECISION_MEANINGS`). */
+  readonly decisionMeaning: Schema.String;
+  /**
+   * The disposition `runRecovery` would report when this decision executes without claim
+   * contention (see `predictRecoveryDisposition`): `repaired` = the recovery pass itself fixes
+   * it; `deferred` = a claiming worker must finish it; `unknown` = durably blocked on the
+   * authorized DUR-017 resolution path; `none` = settled, nothing owed.
+   */
+  readonly disposition: Schema.Literals<readonly ["repaired", "deferred", "none", "unknown"]>;
+  readonly explainedAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+/**
+ * The read-only recovery explanation of one Submission (P7 exit gate "operators can explain
+ * recovery state without editing storage"): the submission summary, the evidence the pure
+ * classifier consumed, the exact `RecoveryDecision` it selected, that decision's operator
+ * meaning, and the disposition the recovery pass would report for it.
+ */
+declare class RecoveryExplanation extends RecoveryExplanation_base {}
+/**
+ * Operator meaning of every recovery decision tag, matching the classifier docstrings in
+ * `recovery.ts` (the classifier remains the semantic authority; this table is its operator
+ * rendering). Exhaustive over `RecoveryDecision` — adding a decision without a meaning is a
+ * compile error here.
+ */
+declare const RECOVERY_DECISION_MEANINGS: Readonly<Record<RecoveryDecision["_tag"], string>>;
+/** The operator meaning of one recovery decision tag. */
+declare const recoveryDecisionMeaning: (tag: RecoveryDecision["_tag"]) => string;
+/**
+ * The disposition the recovery executor reports for a decision when its repair executes without
+ * claim contention (pure prediction; `executeRecoveryDecision` in the coordinator remains the
+ * execution authority — a lane concurrently claimed by a worker can always defer instead).
+ * `AwaitApprovalDecision` depends on the snapshot: an already-suspended lane waits (`deferred`),
+ * while a claimable lane with a lost suspend transition is repaired.
+ */
+declare const predictRecoveryDisposition: (decision: RecoveryDecision, snapshot: RecoverySnapshot) => RecoveryDisposition;
+/** Pure operator text for one explanation (the CLI's `explain` output body). */
+declare const renderRecoveryExplanation: (explanation: RecoveryExplanation) => string;
+/** The named integrity checks `verifyThreadInvariants` performs. */
+declare const IntegrityCheckName: Schema.Literals<readonly ["schema-round-trip", "record-identity", "sequence-contiguity", "digest-chain", "fifo-input-order", "fifo-settlement-order", "terminal-uniqueness", "ledger-canonical-agreement", "checkpoint-binding", "all-settled"]>;
+type IntegrityCheckName = typeof IntegrityCheckName.Type;
+declare const IntegrityCheckStatus: Schema.Literals<readonly ["passed", "failed", "skipped"]>;
+type IntegrityCheckStatus = typeof IntegrityCheckStatus.Type;
+declare const IntegrityCheck_base: Schema.Class<IntegrityCheck, Schema.Struct<{
+  readonly name: Schema.Literals<readonly ["schema-round-trip", "record-identity", "sequence-contiguity", "digest-chain", "fifo-input-order", "fifo-settlement-order", "terminal-uniqueness", "ledger-canonical-agreement", "checkpoint-binding", "all-settled"]>;
+  readonly status: Schema.Literals<readonly ["passed", "failed", "skipped"]>;
+  readonly detail: Schema.optionalKey<Schema.String>;
+}>, {}>;
+/** One typed check result; `detail` explains a failure or the honest reason for a skip. */
+declare class IntegrityCheck extends IntegrityCheck_base {}
+declare const IntegrityReport_base: Schema.Class<IntegrityReport, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly tailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly recordCount: Schema.Int;
+  readonly submissionCount: Schema.Int;
+  readonly checks: Schema.$Array<typeof IntegrityCheck>;
+  readonly ok: Schema.Boolean;
+}>, {}>;
+/**
+ * The read-only integrity verdict for one Thread (plan §3 `verify`): typed per-check
+ * results, never a repair. `ok` is true exactly when no check failed — skipped checks are
+ * honest scope statements, not silent passes.
+ */
+declare class IntegrityReport extends IntegrityReport_base {}
+/**
+ * What one nonterminal Submission is visibly blocked on (DUR-017 operator surface; OPS-001).
+ * `ready-aged`/`running-aged` are not blocks — they are accepted work whose settlement age is
+ * measurable and alertable.
+ */
+declare const ObligationBlockedOn: Schema.Literals<readonly ["unknown", "approval", "waitingForChild", "ready-aged", "running-aged"]>;
+type ObligationBlockedOn = typeof ObligationBlockedOn.Type;
+declare const ObligationSeverity: Schema.Literals<readonly ["ok", "aging", "overdue"]>;
+type ObligationSeverity = typeof ObligationSeverity.Type;
+declare const ObligationThresholds_base: Schema.Class<ObligationThresholds, Schema.Struct<{
+  /** Age (whole seconds) at which an obligation is reported `aging`. */
+  readonly agingSeconds: Schema.Int;
+  /** Age (whole seconds) at which an obligation is reported `overdue`. */
+  readonly overdueSeconds: Schema.Int;
+}>, {}>;
+/** Host-supplied age thresholds; the framework deliberately does not own the alert loop. */
+declare class ObligationThresholds extends ObligationThresholds_base {}
+declare const ObligationEntry_base: Schema.Class<ObligationEntry, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly state: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+  readonly blockedOn: Schema.Literals<readonly ["unknown", "approval", "waitingForChild", "ready-aged", "running-aged"]>;
+  readonly ageSeconds: Schema.Int;
+  readonly severity: Schema.Literals<readonly ["ok", "aging", "overdue"]>;
+}>, {}>;
+/** One nonterminal accepted-work obligation with its age and severity. */
+declare class ObligationEntry extends ObligationEntry_base {}
+declare const ObligationReport_base: Schema.Class<ObligationReport, Schema.Struct<{
+  readonly thresholds: typeof ObligationThresholds;
+  readonly entries: Schema.$Array<typeof ObligationEntry>;
+  readonly generatedAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+/**
+ * The scan-based DUR-017/OPS-001 operator surface (plan §3): a fold of the ledger's nonterminal
+ * scan into aged, severity-classified rows. Scan-based, never a daemon — hosts run it
+ * periodically and export logs/metrics; ages need no storage-version bump because every source
+ * timestamp already exists (`createdAt`/`readyAt`, `suspendedAt`, the canonical
+ * `ToolCallUnknown` record's `createdAt`).
+ */
+declare class ObligationReport extends ObligationReport_base {}
+/** Severity of one obligation age under the supplied thresholds. */
+declare const obligationSeverityOf: (ageSeconds: number, thresholds: ObligationThresholds) => ObligationSeverity;
+declare const RetryCommand_base: Schema.Class<RetryCommand, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * 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.
+ */
+declare class RetryCommand extends RetryCommand_base {}
+/** Why a retry was refused without executing anything. */
+declare const RetryRefusalReason: Schema.Literals<readonly ["settled", "await-unknown-resolution", "await-approval-decision"]>;
+type RetryRefusalReason = typeof RetryRefusalReason.Type;
+declare const RetryRefused_base: Schema.Class<RetryRefused, Schema.TaggedStruct<"RetryRefused", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly refusal: Schema.Literals<readonly ["settled", "await-unknown-resolution", "await-approval-decision"]>;
+  readonly decisionTag: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Typed refusal of `retry` (plan §3): lanes blocked 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.
+ */
+declare class RetryRefused extends RetryRefused_base {}
+//#endregion
+//#region src/durable/internal/journal-checkpoint.d.ts
+declare const JournalCheckpointSeed_base: Schema.Class<JournalCheckpointSeed, Schema.Struct<{
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly throughSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly firstSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+  readonly toolSelection: Schema.optionalKey<typeof Selection>;
+  readonly committedTurns: Schema.Natural;
+  readonly policyUsage: Schema.Struct<{
+    readonly committedTurns: Schema.Natural;
+    readonly toolCalls: Schema.Natural;
+    readonly programmaticToolCalls: Schema.Natural;
+    readonly consecutiveToolFailures: Schema.Natural;
+    readonly finalizationUsed: Schema.Boolean;
+  }>;
+  readonly modelCalls: Schema.Natural;
+  readonly unobservedModelCalls: Schema.Natural;
+  readonly inputTokens: Schema.Natural;
+  readonly outputTokens: Schema.Natural;
+  readonly lastInputTokens: Schema.Natural;
+  readonly lastOutputTokens: Schema.Natural;
+  readonly costMicrousd: Schema.Natural;
+  readonly summarizedModelUsage: typeof RunUsageSummary;
+  readonly protectedContext: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  readonly contextWindowId: Schema.optionalKey<Schema.String>;
+  readonly frontier: Schema.optionalKey<Schema.Struct<{
+    readonly sequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+    readonly tag: Schema.Literals<readonly ["ModelResponseRecorded", "ToolCallSettled"]>;
+  }>>;
+  /** Canonical replacement whose covered batches were validated before retirement. */
+  readonly compaction: typeof CanonicalRecordEnvelope;
+}>, {}>;
+/** Retired accounting is additive; the latest Tool batch always remains replayable verbatim. */
+declare class JournalCheckpointSeed extends JournalCheckpointSeed_base {}
+//#endregion
+//#region src/durable/internal/journal-metadata.d.ts
+/** Metadata for one exact canonical prefix, including the same optional checkpoint seed. */
+interface JournalMetadata {
+  readonly ownerRunId: RunId | undefined;
+  readonly seed: JournalCheckpointSeed | undefined;
+  readonly firstSequenceByRun: ReadonlyMap<string, number>;
+  readonly lastResponseSequenceByRun: ReadonlyMap<string, number>;
+  readonly terminalSequenceByRun: ReadonlyMap<string, number>;
+  readonly settledSpans: ReadonlyArray<{
+    readonly from: number;
+    readonly to: number;
+  }>;
+  readonly settledToolCallRecordIds: ReadonlySet<string>;
+  readonly settledById: ReadonlyMap<string, Pick<ToolCallSettled, "isFailure" | "budgetRejected" | "toolSelection">>;
+  readonly compactions: ReadonlyArray<{
+    readonly payload: CompactionCreated;
+    readonly sequence: number;
+  }>;
+}
+declare namespace RunJournal_d_exports {
+  export { JournalBoundary, RunJournalError, RunJournalProjection, RunJournalUsage, TurnCommitInput, approvalDecisionBatchId, childIdempotencyKeyFor, childThreadIdFor, compactionBatchId, compactionRecordId, markUnknownBatchId, modelResponseInterruptedBatchId, modelResponseInterruptedRecordId, modelResponseRecordId, projectRunJournal, projectRunJournalStream, promptFromCanonicalRecords, runCompletedRecordId, 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;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** A canonical record could not be projected into Run/Prompt state. */
+declare class RunJournalError extends RunJournalError_base {}
+/**
+ * Deterministic Run identity pinned per Submission (plan §Coordinator flow). Every Attempt of one
+ * Submission shares this Run identity, so canonical per-Turn records from different Attempts
+ * belong to one logical Run.
+ */
+declare const runIdForSubmission: (submissionId: SubmissionId) => RunId;
+/** Stable canonical clock identity shared by every Attempt of one Run. */
+declare const runStartedRecordId: (runId: RunId) => RecordId;
+declare const runStartedBatchId: (runId: RunId) => BatchId;
+/** Deterministic Turn identity: Attempt-independent for one (Run, canonical turn) pair. */
+declare const turnIdForRun: (runId: RunId, turn: number) => TurnId;
+/** Deterministic batch identity of one committed canonical no-tool Turn (P4 single-batch shape). */
+declare const turnBatchId: (runId: RunId, turn: number) => BatchId;
+/**
+ * Deterministic batch identity of a tool-declaring Turn's RESPONSE commit (plan §2.1 commit 1):
+ * the assistant response plus pending steering becomes canonical BEFORE approval preflight and
+ * tool preparation, creating the durability §15 "resume tool scheduling" window.
+ */
+declare const turnResponseBatchId: (runId: RunId, turn: number) => BatchId;
+/**
+ * Deterministic batch identity of a tool-declaring Turn's RESULTS commit (plan §2.1 commit 5):
+ * every `ToolCallSettled` record of the Turn, in declaration order, model-visible atomically.
+ */
+declare const turnResultsBatchId: (runId: RunId, turn: number) => BatchId;
+/**
+ * Deterministic per-call late-settle batch identity used by the resolution path when one
+ * recovered/resolved call settles outside its Turn's results batch. Record identity
+ * (`tool-settled:{runId}:{turn}:{toolCallId}`) dedupes double-settles across both paths.
+ */
+declare const toolCallResultBatchId: (runId: RunId, turn: number, toolCallId: ToolCallId) => BatchId;
+/** Deterministic batch identity of one Turn's `ToolCallPrepared` commit (plan §2.1 commit 3). */
+declare const turnPreparedBatchId: (runId: RunId, turn: number) => BatchId;
+/**
+ * Deterministic identity of one pre-Turn compaction record (RUN-026,
+ * RUN-026). Keyed by Run, Turn, and kind — the engine performs at most one
+ * threshold compaction per Turn plus at most one overflow-forced summarize,
+ * so a superseding Attempt that re-decides the same compaction replays the
+ * batch identity instead of duplicating the record.
+ */
+declare const compactionRecordId: (runId: RunId, turn: number, kind: "clear-tool-results" | "summarize" | "rollover") => RecordId;
+/** Deterministic batch identity of one compaction append (same string as its record id). */
+declare const compactionBatchId: (runId: RunId, turn: number, kind: "clear-tool-results" | "summarize" | "rollover") => BatchId;
+/** Deterministic canonical record identity of one Turn's `ModelResponseRecorded` record. */
+declare const modelResponseRecordId: (runId: RunId, turn: number) => RecordId;
+/** Terminal Tool completion marker committed atomically with its settled Tool result. */
+declare const runCompletedRecordId: (runId: RunId) => RecordId;
+/** Deterministic canonical record identity of one Turn's `ToolCallSettled` record. */
+declare const toolCallSettledRecordId: (runId: RunId, turn: number, toolCallId: ToolCallId) => RecordId;
+/** Deterministic canonical record identity of one Tool Call's `ToolCallPrepared` record. */
+declare const toolCallPreparedRecordId: (runId: RunId, turn: number, toolCallId: ToolCallId) => RecordId;
+/** 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. */
+declare const toolCallUnknownRecordId: (runId: RunId, turn: number, toolCallId: ToolCallId) => RecordId;
+/** Deterministic batch identity of one Tool Call's resolution append (DUR-017). */
+declare const toolCallResolutionBatchId: (submissionId: SubmissionId, toolCallId: ToolCallId) => BatchId;
+/** Deterministic canonical record identity of one Tool Call's `ToolCallResolved` record. */
+declare const toolCallResolvedRecordId: (runId: RunId, turn: number, toolCallId: ToolCallId) => RecordId;
+/**
+ * Deterministic identity of one accepted Durable Step result. The one-record batch reuses the
+ * SAME string, so batch idempotency plus the epoch fence realize the durability §11
+ * racing-writers rule: only the fenced winner's record commits; the loser replays it.
+ * A versioned JSON tuple keeps separator characters in each identity component distinct.
+ * Replay derives this key from the structured payload, including records with legacy IDs.
+ */
+declare const toolStepSettledRecordId: (runId: RunId, toolCallId: ToolCallId, stepName: string) => RecordId;
+/** Deterministic batch identity of one Durable Step commit (same string as its record id). */
+declare const toolStepSettledBatchId: (runId: RunId, toolCallId: ToolCallId, stepName: string) => BatchId;
+/** Deterministic batch identity of one Turn's canonical approval-request append (plan §2.6). */
+declare const turnApprovalsBatchId: (runId: RunId, turn: number) => BatchId;
+/** Deterministic canonical record identity of one Tool Call's `ToolApprovalRequested` record. */
+declare const toolApprovalRequestRecordId: (runId: RunId, turn: number, toolCallId: ToolCallId) => RecordId;
+/** Deterministic batch identity of one Tool Call's canonical approval-decision append. */
+declare const approvalDecisionBatchId: (submissionId: SubmissionId, toolCallId: ToolCallId) => BatchId;
+/** Deterministic canonical record identity of one Tool Call's `ToolApprovalDecided` record. */
+declare const toolApprovalDecisionRecordId: (runId: RunId, turn: number, toolCallId: ToolCallId) => RecordId;
+/**
+ * Deterministic identity of one superseded Attempt's `ModelResponseInterrupted` audit record
+ * (durability §9). Keyed by the superseded epoch, so each interrupted ownership period is
+ * recorded at most once; the one-record batch reuses the same string.
+ */
+declare const modelResponseInterruptedRecordId: (runId: RunId, supersededEpoch: number) => RecordId;
+/** Deterministic batch identity of one `ModelResponseInterrupted` append (same string). */
+declare const modelResponseInterruptedBatchId: (runId: RunId, supersededEpoch: number) => BatchId;
+/**
+ * Deterministic canonical record identity of one parent Tool Call's `SubagentRequested` record.
+ * The one-record batch reuses the same string, so batch
+ * idempotency plus the parent epoch fence make the request append exactly-once-canonical.
+ */
+declare const subagentRequestedRecordId: (runId: RunId, toolCallId: ToolCallId) => RecordId;
+/** Deterministic batch identity of one `SubagentRequested` append (same string). */
+declare const subagentRequestedBatchId: (runId: RunId, toolCallId: ToolCallId) => BatchId;
+/**
+ * Deterministic canonical record identity of one parent Tool Call's `SubagentStarted` record.
+ * Recovery's start-link repair appends the EXACT same record
+ * under this identity, so a raced repair replays instead of duplicating (SUB-016/SUB-017).
+ */
+declare const subagentStartedRecordId: (runId: RunId, toolCallId: ToolCallId) => RecordId;
+/** Deterministic batch identity of one `SubagentStarted` append (same string). */
+declare const subagentStartedBatchId: (runId: RunId, toolCallId: ToolCallId) => BatchId;
+/**
+ * Deterministic batch identity of one parent Tool Call's atomic settlement join: the
+ * `SubagentJoined` record plus the parent's `ToolCallSettled` record (its existing
+ * `tool-settled:{runId}:{turn}:{toolCallId}` identity) commit as ONE canonical batch (SUB-019).
+ */
+declare const subagentJoinBatchId: (runId: RunId, toolCallId: ToolCallId) => BatchId;
+/** Deterministic canonical record identity of one parent Tool Call's `SubagentJoined` record. */
+declare const subagentJoinedRecordId: (runId: RunId, toolCallId: ToolCallId) => RecordId;
+/**
+ * Deterministic identity of one child Thread's `SubagentLineageRecorded` record.
+ * Its own single-record batch reuses the same string so the generic
+ * `thread-created:{cid}` batch identity is never contradicted.
+ */
+declare const subagentLineageRecordId: (threadId: ThreadId) => RecordId;
+/** Deterministic batch identity of one `SubagentLineageRecorded` append (same string). */
+declare const subagentLineageBatchId: (threadId: ThreadId) => BatchId;
+/**
+ * Deterministic intended child Thread identity: the
+ * parent Submission and Tool Call pair addresses exactly one child Thread, so a replayed
+ * establishment converges on the one existing child (SUB-016).
+ */
+declare const childThreadIdFor: (parentSubmissionId: SubmissionId, toolCallId: ToolCallId) => ThreadId;
+/**
+ * Deterministic child admission idempotency key: scoped to
+ * the parent Run and Tool Call identity, so duplicate admission attempts resolve through the
+ * ledger's idempotency contract to one child Receipt (SUB-016, SUB-031). The ledger key is
+ * bounded (256); coordinator-minted Run and Tool Call identities stay far below that bound.
+ */
+declare const childIdempotencyKeyFor: (parentRunId: RunId, toolCallId: ToolCallId) => IdempotencyKey;
+/**
+ * Pure canonical projection of one Run's durable execution state.
+ *
+ * Prompt reconstruction contract (D8):
+ *
+ * - `ModelResponseRecorded.messages` carries the Schema-encoded Prompt messages the Turn appended
+ *   to the model-visible prompt — for the Run's FIRST committed Turn that includes the evaluated
+ *   instruction and user-input messages, for later Turns only the assistant response messages.
+ *   Tool messages are excluded from `messages`.
+ * - `ToolCallSettled` records (committed in the same per-Turn batch, in declaration order)
+ *   deterministically rebuild the Turn's single Tool message.
+ * - `UserInputRecorded` records input, with a Submission identity only for durable admission. Its
+ *   Prompt-visible form (instructions + user message) becomes canonical inside the owning Run's
+ *   first `ModelResponseRecorded`. The projection consumes it only for Run correlation.
+ * - Immediate retained history uses `ModelCompleted.messages` for the successful Run's exact
+ *   native Prompt suffix, including any input examples. It has no resumable Turn state.
+ */
+/** Cumulative committed usage of the projected Run (RUN-023 resume re-seed). */
+interface RunJournalUsage {
+  readonly modelCalls: number;
+  /** Known accounting gaps retained across Attempts without changing numeric usage totals. */
+  readonly unobservedModelCalls?: number | undefined;
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly lastInputTokens: number;
+  readonly lastOutputTokens: number;
+  /** Cumulative persisted spend of the projected Run's committed calls (RUN-023). */
+  readonly costMicrousd: number;
+  /** Canonical per-call detail used for settlement aggregation and recovery. */
+  readonly modelUsage: ReadonlyArray<ModelCallUsage>;
+  /** Detailed usage of retired records, grouped without retaining per-call payloads. */
+  readonly summarizedModelUsage?: RunUsageSummary | undefined;
+}
+interface RunJournalProjection {
+  readonly toolSelection?: Selection | undefined;
+  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. */
+  readonly historyBefore: Prompt.Prompt;
+  /** Number of canonical Turns already committed for the projected Run. */
+  readonly committedTurns: number;
+  /** Summed per-call usage of the projected Run's committed responses; zeros for records predating usage capture. */
+  readonly usage: RunJournalUsage;
+  /** Latest committed context window identity, retained across ownership changes. */
+  readonly contextWindowId?: string | undefined;
+  /** Canonical evaluated instructions and initial input for this Run, independent of the view. */
+  readonly protectedContext?: Prompt.Prompt | undefined;
+  /** Last successful singleton Tool awaiting possible context-control interpretation by the engine. */
+  readonly pendingContextToolCallId?: string | undefined;
+}
+/**
+ * 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,
+ * 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
+ * are skipped transparently, so split-batch commits replay to the same prompt as P4 single-batch
+ * commits.
+ *
+ * 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.
+ */
+/** @internal Lightweight canonical boundaries collected without retaining record payloads. */
+interface JournalBoundary {
+  readonly sequence: CanonicalSequence;
+  readonly tag: "ModelResponseRecorded" | "ToolCallSettled";
+  readonly promptLength: number;
+  /** A declaration without all settled results requires terminal-prior-Run proof for coverage. */
+  readonly incomplete?: true | undefined;
+  /** The Run terminated after its last response and differs from the projection's owner. */
+  readonly terminalPriorRun?: true | undefined;
+}
+/**
+ * Reconstruct a fixed canonical prefix from a re-readable stream. The caller must keep the same
+ * records visible on every traversal. The first collects compaction and settlement metadata;
+ * rollovers additionally validate covered Tool batches before rebuilding Prompt and usage. Metadata and the
+ * live Prompt remain resident; covered historical message/tool payloads do not. An uncompacted Prompt still grows
+ * with its conversation, so hosts must configure an appropriate context compaction policy.
+ * Prepared metadata must describe exactly this stream and seed through the same fixed tail;
+ * it skips only the metadata scan, never covered-Tool validation or the canonical fold.
+ * @internal
+ */
+declare const projectRunJournalStream: <E, R>(records: Stream.Stream<CanonicalRecordEnvelope, E, R>, ownerRunId: (string & import("effect/Brand").Brand<"@effect-agent/core/RunId">) | undefined, onBoundary?: ((boundary: JournalBoundary) => void) | undefined, seed?: JournalCheckpointSeed | undefined, preparedMetadata?: JournalMetadata | undefined) => Effect.Effect<RunJournalProjection, E | RunJournalError, R>;
+/** Pure projection of one Run's durable recovery state from canonical records. */
+declare const projectRunJournal: (records: readonly CanonicalRecordEnvelope[], runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">) => Effect.Effect<RunJournalProjection, RunJournalError, never>;
+/**
+ * Pure valid-prompt projection from canonical records: `UserInputRecorded` +
+ * `ModelResponseRecorded` + complete `ToolCallSettled` batches → the deterministic model-visible
+ * Prompt (plan §Coordinator flow step 3).
+ */
+declare const promptFromCanonicalRecords: (records: readonly CanonicalRecordEnvelope[]) => Effect.Effect<Prompt.Prompt, RunJournalError, never>;
+interface TurnCommitInput {
+  readonly toolExposure?: Snapshot | undefined;
+  readonly toolSelections?: ReadonlyMap<string, Selection> | undefined;
+  readonly budgetRejectedCalls?: ReadonlySet<string>;
+  readonly runId: RunId;
+  /** Canonical (Run-relative, Attempt-independent) Turn number; must be positive. */
+  readonly turn: number;
+  readonly turnId: TurnId;
+  /**
+   * The Prompt messages this Turn appended to official history, in order, including the Turn's
+   * Tool message when application Tools ran. Tool messages become `ToolCallSettled` records; the
+   * remaining messages become the Turn's `ModelResponseRecorded.messages`.
+   */
+  readonly appended: ReadonlyArray<Prompt.Message>;
+  readonly producerId: ProducerId;
+  readonly deploymentId: DeploymentId;
+  readonly createdAt: DateTime.Utc;
+  /** Leading instruction/wake messages that stay canonical but are hidden from later Runs. */
+  readonly runScopedPrefixLength?: number | undefined;
+  /** Terminal output committed atomically with this Turn's final canonical batch. */
+  readonly runCompletion?: {
+    readonly output: PersistedJson;
+    readonly runDisposition?: PersistedJson | undefined;
+    readonly finishReason?: "budget-exhausted" | undefined;
+    readonly exhausted?: ExhaustedLimit | undefined;
+  } | undefined;
+  /** Known missing-accounting invocations staged before this canonical response. */
+  readonly unobservedModelCalls?: number | undefined;
+  /** Per-call provider usage staged by the engine's `noteTurnUsage` (RUN-023). */
+  readonly usage?: {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly costMicrousd?: number | undefined;
+    readonly modelUsage?: ReadonlyArray<ModelCallUsage> | undefined;
+  } | undefined;
+}
+/**
+ * Pure per-Turn canonical batch builder (TurnCompleted seam fold, D6/D8): one
+ * `ModelResponseRecorded` record plus one `ToolCallSettled` record per terminal Tool result, all
+ * under the WP0-style deterministic identities, committed as ONE atomic batch. The same input
+ * always yields byte-identical content, so an in-Attempt append retry is an honest batch replay.
+ *
+ * Phase 5 keeps this shape for Turns that declare no application Tool calls; their terminal
+ * `RunCompleted` marker joins the response in this same atomic batch. Tool-declaring Turns split
+ * into `turnResponseBatch` + `turnResultsBatch`.
+ */
+declare const turnCanonicalBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, DigestError | RunJournalError, Crypto.Crypto>;
+/**
+ * Commit 1 of a tool-declaring Turn: the Turn's `ModelResponseRecorded` record, including
+ * provider results retained in assistant content before application Tools execute.
+ * — pending steering plus the assistant response with its declared tool calls — under batch
+ * identity `turn-response:{runId}:{turn}`. Committing the response before preparation creates
+ * the provably-safe durability §15 window ("after model item commit, before tool preparation →
+ * resume tool scheduling"): a crash there resumes the declared batch with no model re-invocation
+ * and no Unknown. Tool messages in `appended` are ignored; the record identity is the same
+ * `model-response:{runId}:{turn}` as the single-batch shape, so record-id assertions and the
+ * prompt projection are unchanged.
+ */
+declare const turnResponseBatch: (input: TurnCommitInput) => Effect.Effect<CanonicalBatch, DigestError | RunJournalError, Crypto.Crypto>;
+/**
+ * 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. 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 namespace SubmissionStatus_d_exports {
+  export { PendingSubmission, SettledSubmission, SubmissionStatus };
+}
+declare const PendingSubmission_base: Schema.Class<PendingSubmission, Schema.TaggedStruct<"pending", {}>, {}>;
+/** A Submission still owes its canonical Settlement, including while suspended. */
+declare class PendingSubmission extends PendingSubmission_base {}
+declare const SettledSubmission_base: Schema.Class<SettledSubmission, Schema.TaggedStruct<"settled", {
+  readonly settlement: typeof Settlement;
+}>, {}>;
+/** The existing durable Settlement is the only authority for completion. */
+declare class SettledSubmission extends SettledSubmission_base {}
+declare const SubmissionStatus: Schema.Union<readonly [typeof PendingSubmission, typeof SettledSubmission]>;
+type SubmissionStatus = typeof SubmissionStatus.Type;
+declare namespace ThreadStore_d_exports {
+  export { AppendConflict, AppendResult, CheckpointRejected, FenceRejected, FencedAppendRequest, LoadCheckpointRequest, MAX_THREAD_EXPORT_RECORDS, SaveCheckpointRequest, SaveRecoveryCheckpointRequest, ThreadCheckpoint, ThreadCheckpoints, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadRecoveryCheckpoints, ThreadStore, ThreadStoreError, ThreadStoreFailure, ThreadTail, ThreadTailRequest };
+}
+declare const ThreadMaterialization_base: Schema.Class<ThreadMaterialization, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly producerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+}>, {}>;
+declare class ThreadMaterialization extends ThreadMaterialization_base {}
+declare const FencedAppendRequest_base: Schema.Class<FencedAppendRequest, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly batch: typeof CanonicalBatch;
+  readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly producerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+}>, {}>;
+declare class FencedAppendRequest extends FencedAppendRequest_base {}
+declare const AppendResult_base: Schema.Class<AppendResult, Schema.Struct<{
+  readonly firstSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly lastSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly tailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly replayed: Schema.Boolean;
+}>, {}>;
+declare class AppendResult extends AppendResult_base {}
+declare const ThreadRead_base: Schema.Class<ThreadRead, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly afterSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+  readonly limit: Schema.Natural;
+}>, {}>;
+declare class ThreadRead extends ThreadRead_base {}
+declare const ThreadObservation_base: Schema.Class<ThreadObservation, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly afterOffset: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ObservationOffset">>;
+}>, {}>;
+declare class ThreadObservation extends ThreadObservation_base {}
+declare const ThreadExportRequest_base: Schema.Class<ThreadExportRequest, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>, {}>;
+declare class ThreadExportRequest extends ThreadExportRequest_base {}
+declare const ThreadTailRequest_base: Schema.Class<ThreadTailRequest, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>, {}>;
+declare class ThreadTailRequest extends ThreadTailRequest_base {}
+declare const ThreadTail_base: Schema.Class<ThreadTail, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly tailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly tailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly producerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+}>, {}>;
+/**
+ * The committed tail of one Thread Log. A resuming producer composes its next
+ * FencedAppendRequest from this value instead of exporting the whole log.
+ */
+declare class ThreadTail extends ThreadTail_base {}
+/** Maximum canonical records represented by one Thread export. */
+declare const MAX_THREAD_EXPORT_RECORDS = 131072;
+declare const ThreadExport_base: Schema.Class<ThreadExport, Schema.Struct<{
+  readonly format: Schema.Literal<"effect-agent/thread@1">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly tailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly tailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly records: Schema.$Array<typeof CanonicalRecordEnvelope>;
+}>, {}>;
+declare class ThreadExport extends ThreadExport_base {}
+declare const ThreadCheckpoint_base: Schema.Class<ThreadCheckpoint, Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly throughSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly tailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  /** @deprecated For application projections; retained for existing data and runtime recovery. */
+  readonly engineVersion: Schema.optionalKey<Schema.NonEmptyString>;
+  /** @deprecated For application projections; retained for existing data and runtime recovery. */
+  readonly agentDefinitionDigest: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+  /** @deprecated For application projections; retained for existing data and runtime recovery. */
+  readonly modelDigest: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+  /** @deprecated For application projections; retained for existing data and runtime recovery. */
+  readonly toolDigest: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+  readonly state: Schema.declare<Schema.Json, Schema.Json>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+}>, {}>;
+/**
+ * A disposable projection snapshot. Adapters bind its sequence and digest to the canonical
+ * log; consumers decode `state` and decide projection compatibility before suffix replay.
+ * Legacy metadata is optional for application projections and preserved when supplied.
+ * Runtime-owned recovery checkpoints populate and compare it before using cached state.
+ */
+declare class ThreadCheckpoint extends ThreadCheckpoint_base {}
+declare const SaveCheckpointRequest_base: Schema.Class<SaveCheckpointRequest, Schema.Struct<{
+  readonly checkpoint: typeof ThreadCheckpoint;
+}>, {}>;
+declare class SaveCheckpointRequest extends SaveCheckpointRequest_base {}
+declare const SaveRecoveryCheckpointRequest_base: Schema.Class<SaveRecoveryCheckpointRequest, Schema.Struct<{
+  readonly checkpoint: typeof ThreadCheckpoint;
+  readonly producerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+}>, {}>;
+/** Replace the disposable recovery view only under the current canonical producer fence. */
+declare class SaveRecoveryCheckpointRequest extends SaveRecoveryCheckpointRequest_base {}
+declare const LoadCheckpointRequest_base: Schema.Class<LoadCheckpointRequest, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly atOrBeforeSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+}>, {}>;
+declare class LoadCheckpointRequest extends LoadCheckpointRequest_base {}
+declare const ThreadStoreError_base: Schema.Class<ThreadStoreError, Schema.TaggedStruct<"ThreadStoreError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+declare class ThreadStoreError extends ThreadStoreError_base {}
+declare const ThreadNotMaterialized_base: Schema.Class<ThreadNotMaterialized, Schema.TaggedStruct<"ThreadNotMaterialized", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>, import("effect/Cause").YieldableError>;
+declare class ThreadNotMaterialized extends ThreadNotMaterialized_base {}
+declare const AppendConflict_base: Schema.Class<AppendConflict, Schema.TaggedStruct<"AppendConflict", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly batchId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/BatchId">;
+  readonly reason: Schema.Literals<readonly ["batch-digest", "record-identity", "tail"]>;
+  readonly actualTailSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+  readonly actualTailDigest: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A canonical append that cannot commit: `batch-digest` replays a batch ID with different
+ * content, `record-identity` reuses a canonical record ID, and `tail` declares a stale expected
+ * tail. Tail conflicts carry the actual committed tail as a diagnostic resume hint.
+ */
+declare class AppendConflict extends AppendConflict_base {}
+declare const FenceRejected_base: Schema.Class<FenceRejected, Schema.TaggedStruct<"FenceRejected", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly actualEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+  readonly attemptedEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+}>, import("effect/Cause").YieldableError>;
+declare class FenceRejected extends FenceRejected_base {}
+declare const CheckpointRejected_base: Schema.Class<CheckpointRejected, Schema.TaggedStruct<"CheckpointRejected", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly reason: Schema.Literals<readonly ["ahead-of-tail", "digest-mismatch", "unsupported-version", "corrupt"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class CheckpointRejected extends CheckpointRejected_base {}
+type ThreadStoreFailure = ThreadStoreError | ThreadNotMaterialized | AppendConflict | FenceRejected;
+/**
+ * Optional, disposable projection storage. Neither history execution nor durable recovery
+ * requires it. Adapters that offer it must bind every checkpoint to a canonical batch tail.
+ * Application consumers own projection compatibility; this port does not interpret metadata.
+ */
+interface ThreadCheckpoints {
+  readonly save: (request: SaveCheckpointRequest) => Effect.Effect<void, ThreadStoreError | ThreadNotMaterialized | CheckpointRejected>;
+  readonly load: (request: LoadCheckpointRequest) => Effect.Effect<Option.Option<ThreadCheckpoint>, ThreadStoreError | ThreadNotMaterialized | CheckpointRejected>;
+}
+/**
+ * Optional latest-only recovery cache, independent of application projection checkpoints.
+ * Saves atomically validate the producer epoch and canonical batch tail. An older snapshot
+ * cannot replace a newer one; equal-tail replacement repairs disposable state. Invalid cached
+ * data fails with CheckpointRejected, while infrastructure failures remain ThreadStoreError.
+ * Loading at an earlier tail or outside the adapter's cache locality may return none so callers
+ * can replay canonical records. Canonical records and the ledger remain authority.
+ */
+interface ThreadRecoveryCheckpoints {
+  readonly save: (request: SaveRecoveryCheckpointRequest) => Effect.Effect<void, ThreadStoreError | ThreadNotMaterialized | CheckpointRejected | FenceRejected>;
+  readonly load: ThreadCheckpoints["load"];
+}
+declare const ThreadStore_base: Context.ServiceClass<ThreadStore, "@effect-agent/thread/ThreadStore", {
+  readonly materialize: (request: ThreadMaterialization) => Effect.Effect<void, ThreadStoreError | FenceRejected>;
+  readonly append: (request: FencedAppendRequest) => Effect.Effect<AppendResult, ThreadStoreError | ThreadNotMaterialized | AppendConflict | FenceRejected>;
+  readonly read: (request: ThreadRead) => Stream.Stream<CanonicalRecordEnvelope, ThreadStoreError | ThreadNotMaterialized>;
+  readonly observe: (request: ThreadObservation) => Stream.Stream<CanonicalRecordEnvelope, ThreadStoreError | ThreadNotMaterialized>;
+  readonly export: (request: ThreadExportRequest) => Effect.Effect<ThreadExport, ThreadStoreError | ThreadNotMaterialized>;
+  readonly inspectTail: (request: ThreadTailRequest) => Effect.Effect<ThreadTail, ThreadStoreError | ThreadNotMaterialized>;
+  /** Absent when this adapter does not support disposable checkpoints. */
+  readonly checkpoints?: ThreadCheckpoints | undefined;
+  readonly recoveryCheckpoints?: ThreadRecoveryCheckpoints | undefined;
+}>;
+declare class ThreadStore extends ThreadStore_base {}
+declare namespace DurableAgentRuntime_d_exports {
+  export { DurableAbortFailure, DurableAgentRuntime, DurableApprovalFailure, DurableApprovalResolver, DurableAwaitFailure, DurableExplainFailure, DurableObligationFailure, DurableObserveOptions, DurableProgressFailure, DurableResolveFailure, DurableRetryFailure, DurableRuntimeConfig, DurableRuntimeConfigOptions, DurableSubmitAgent, DurableSubmitFailure, DurableSubmitOptions, DurableVerifyFailure, DurableWorkerFailure, DurableWorkerRequirements, Receipt, RecoveryReport, childReservationIdFor, recoveryRepairBatchId, recoveryRepairRecordId, threadCreatedBatchId, threadCreatedRecordId };
+}
+/**
+ * Instruction failure/requirement derivation mirroring the engine's `RuntimeBinding` defaults:
+ * declaring them as generic DEFAULTS (instead of independent inference sites) keeps a plain
+ * string-returning instruction function from widening both parameters to `unknown`.
+ */
+type InstructionResultOf<Instructions, Input> = Instructions extends ((input: Input) => infer Result) ? Result : Instructions;
+type InstructionErrorOf<Instructions, Input> = InstructionResultOf<Instructions, Input> extends Effect.Effect<infer _Success, infer Error, infer _Requirements> ? Error : never;
+type InstructionRequirementsOf<Instructions, Input> = InstructionResultOf<Instructions, Input> extends Effect.Effect<infer _Success, infer _Error, infer Requirements> ? Requirements : never;
+/**
+ * Deterministic parent-owned child budget reservation identity (spec
+ * §12 step 2, D4): one reservation per (parent Run, parent Tool Call) pair,
+ * so a replayed establishment converges on the one existing row (SUB-016).
+ */
+declare const childReservationIdFor: (runId: RunId, toolCallId: ToolCallId) => ChildReservationId;
+/** Deterministic batch identity of one Thread's initial `ThreadCreated` append. */
+declare const threadCreatedBatchId: (threadId: ThreadId) => BatchId;
+/** Deterministic record identity of one Thread's `ThreadCreated` record. */
+declare const threadCreatedRecordId: (threadId: ThreadId) => RecordId;
+/** Deterministic batch identity of one executed recovery decision's audit append (DUR-013). */
+declare const recoveryRepairBatchId: (submissionId: SubmissionId, decisionTag: string) => BatchId;
+/** Deterministic record identity of one executed recovery decision's `RepairAnnotated` record. */
+declare const recoveryRepairRecordId: (submissionId: SubmissionId, decisionTag: string) => RecordId;
+declare const RecoveryReport_base: Schema.Class<RecoveryReport, Schema.Struct<{
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  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
+   * DUR-017 resolution path — the settlement obligation stays visible while no worker permit
+   * is consumed (durability §16).
+   */
+  readonly disposition: Schema.Literals<readonly ["repaired", "deferred", "none", "unknown"]>;
+}>, {}>;
+/** One executed (or deliberately deferred) recovery decision (durability §14, DUR-013). */
+declare class RecoveryReport extends RecoveryReport_base {}
+/** Per-submission options accepted by `DurableAgentRuntime.submit` (D2). */
+interface DurableSubmitOptions {
+  readonly threadId: ThreadId;
+  readonly principal: Principal;
+  readonly idempotencyKey: IdempotencyKey;
+  readonly admissionGroup?: string;
+  readonly admissionFence?: AdmissionFence;
+  /** Host-prepared worker input; immutable origin and per-input projection parameters. */
+  readonly workerAdmission?: WorkerAdmission;
+  /** Peer provenance or a worker completion, verified against frozen canonical delivery proof. */
+  readonly messageAdmission?: InputMessage;
+  /** Application-computed digests of the Agent/Model/Toolkit definitions (see `digestDefinitions`). */
+  readonly definitions: DefinitionDigests;
+}
+interface DurableObserveOptions {
+  /** Resume the observation after an adapter-owned offset previously returned by `observe`. */
+  readonly after?: CanonicalRecordEnvelope["offset"] | undefined;
+}
+/** The structural slice of an Agent Binding that `submit` needs. */
+interface DurableSubmitAgent<InputSchema extends Schema.Top> {
+  readonly definition: {
+    readonly id: AgentId;
+    readonly input: InputSchema;
+  };
+}
+type DurableSubmitFailure = AgentInputError | DigestError | AdmissionConflict | AdmissionPolicyError | LedgerError | ThreadStoreError | ThreadNotMaterialized | AppendConflict | FenceRejected | DurableRuntimeFailpointError;
+type DurableWorkerFailure = AdmissionPolicyError | DigestError | LedgerError | OwnershipLost | SettlementConflict | ThreadStoreError | ThreadNotMaterialized | AppendConflict | FenceRejected | RunJournalError | DurableRuntimeFailpointError;
+type DurableAwaitFailure = LedgerError | SettlementConflict | OperationDenied;
+/** Typed failures from the public canonical progress boundary. */
+type DurableProgressFailure = ThreadStoreError | ThreadNotMaterialized | OperationDenied;
+type DurableAbortFailure = OperationDenied | LedgerError | SettlementConflict | JoinedToHost | DurableRuntimeFailpointError;
+/**
+ * Failure family of `resolveUnknown` (DUR-017, abort-shaped): the durable intent may conflict
+ * with a divergent prior resolution, the Submission may already be settled, an `AbortSubmission`
+ * resolution routes through the abort path (whose `JoinedToHost` conflict stays visible), and the
+ * failpoint after the intent write is armable like every other durable mutation.
+ */
+type DurableResolveFailure = LedgerError | SettlementConflict | UnknownResolutionConflict | JoinedToHost | DurableRuntimeFailpointError;
+/**
+ * Failure family of `resolveApproval` (plan §2.6, abort-shaped): the durable intent may conflict
+ * with a divergent prior decision, and the Submission may already be settled. The ledger adapter
+ * owns the crash boundaries of the intent write (`ledger:approval-decision:{before,after}`).
+ */
+type DurableApprovalFailure = LedgerError | SettlementConflict | ApprovalConflict;
+/**
+ * Failure family of the read-only `explain`/`explainThread` operations (P7 WP1): pure
+ * observation over the two ports plus the evidence assembler's typed failures, and the
+ * fail-closed `OperationDenied` when a host-supplied authorizer refuses.
+ */
+type DurableExplainFailure = LedgerError | ThreadStoreError | RunJournalError | OperationDenied;
+/**
+ * Failure family of the read-only `verify` operation (P7 WP1). `ThreadNotMaterialized`
+ * stays visible: verifying a Thread that does not exist is a caller error, not an empty
+ * report.
+ */
+type DurableVerifyFailure = LedgerError | ThreadStoreError | ThreadNotMaterialized | OperationDenied;
+/**
+ * Failure family of `retry` (P7 WP1): the scoped recovery execution carries the worker failure
+ * family, refusals are typed (`RetryRefused` — settled work and lanes owned by the
+ * resolveUnknown/resolveApproval paths), and denial is fail-closed.
+ */
+type DurableRetryFailure = DurableWorkerFailure | RetryRefused | OperationDenied;
+/** Failure family of `scanObligations` (P7 WP1): ledger scan + canonical unknown-age reads. */
+type DurableObligationFailure = LedgerError | ThreadStoreError | OperationDenied;
+/**
+ * Optional policy-auto approval delegate consulted by the durable approval hook (plan §2.6 step
+ * 2) AFTER the recorded-decision lookup misses. An immediate `approved`/`denied` answer becomes
+ * canonical (`ToolApprovalRequested` + `ToolApprovalDecided`, one atomic batch) before it is
+ * honored; `unresolved` falls through to the durable suspension path. The default (`undefined`)
+ * suspends every undecided approval durably until `resolveApproval` decides it — the fail-closed
+ * posture. Adapt the P2 `ApprovalResolver` capability stack through
+ * `@effect-agent/capabilities`' `toDurableRunApprovalHook`.
+ */
+declare const DurableApprovalResolver: Context.Reference<RunApprovalHook<never, never> | undefined>;
+/**
+ * Services a durable worker needs beyond the runtime's own Layer: the Agent Binding's inferred
+ * requirements minus its supplied identity and history services. The coordinator provides
+ * deterministic Run/Turn identity and journal-owned history because its coordinator owns all
+ * durable reads and commits across Attempts.
+ */
+type DurableWorkerRequirements<AgentValue extends Any, InstructionRequirements = never> = Exclude<AgentRuntimeRequirements<AgentValue, never, InstructionRequirements>, ThreadHistory | RunContextPreparation> | AgentCompletionProjectionRequirements<AgentValue>;
+interface DurableRuntimeConfigOptions {
+  readonly deploymentId: DeploymentId;
+  readonly producerId: ProducerId;
+  /** `awaitSettlement` ledger re-check cadence when no wake arrives (default 500ms). */
+  readonly settlementPollInterval?: Duration.Duration | undefined;
+  /** Worker ownership-lease renewal cadence (default 10s; D5 lease default is 30s). */
+  readonly leaseRenewalInterval?: Duration.Duration | undefined;
+  /** Active-Run abort-intent poll cadence (default 500ms). */
+  readonly abortPollInterval?: Duration.Duration | undefined;
+  /** Deployment-owned model pricing authority, captured for every recoverable Run. */
+  readonly estimateCostMicrousd?: RunCostEstimator | undefined;
+}
+declare const DurableRuntimeConfig_base: Context.ServiceClass<DurableRuntimeConfig, "@effect-agent/thread/DurableRuntimeConfig", {
+  readonly deploymentId: DeploymentId;
+  readonly producerId: ProducerId;
+  readonly settlementPollInterval: Duration.Duration;
+  readonly leaseRenewalInterval: Duration.Duration;
+  readonly abortPollInterval: Duration.Duration;
+  readonly estimateCostMicrousd?: RunCostEstimator | undefined;
+}>;
+/** Deployment-scoped identity and liveness cadences for the durable coordinator. */
+declare class DurableRuntimeConfig extends DurableRuntimeConfig_base {
+  static make(options: DurableRuntimeConfigOptions): (typeof DurableRuntimeConfig)["Service"];
+  static layer(options: DurableRuntimeConfigOptions): Layer.Layer<DurableRuntimeConfig>;
+}
+declare const DurableAgentRuntime_base: Context.ServiceClass<DurableAgentRuntime, "@effect-agent/thread/DurableAgentRuntime", {
+  /** Acquire an authenticated source Thread facet; its References confer no authority. */
+  readonly workerHost: (request: {
+    readonly sourceThreadId: ThreadId;
+    readonly principal: Principal;
+    /** Exact retained owner input for captured source policy; never selects the latest input. */
+    readonly sourceSubmissionId?: SubmissionId;
+  }) => Effect.Effect<SubagentHost["Service"], WorkerError>;
+  readonly messagingHost: (request: {
+    readonly sourceThreadId: ThreadId;
+    readonly principal: Principal;
+  }) => Effect.Effect<MessagingHost["Service"], MessagingError>;
+  /** Admit the exact registered Definition instance; reject missing, ambiguous, or different definitions. */
+  readonly submitRegistered: <InputSchema extends Schema.Top>(agent: DurableSubmitAgent<InputSchema>, input: InputSchema["Type"], options: Omit<DurableSubmitOptions, "definitions">) => Effect.Effect<Receipt, DurableSubmitFailure | BindingUnavailable, InputSchema["EncodingServices"]>;
+  /** Authorized exact canonical terminal record, including the encoded output. Reject pending work. */
+  readonly settlementRecord: (receipt: Receipt) => Effect.Effect<SubmissionSettledRecord, DurableAwaitFailure>;
+  readonly submit: <InputSchema extends Schema.Top>(agent: DurableSubmitAgent<InputSchema>, input: InputSchema["Type"], options: DurableSubmitOptions) => Effect.Effect<Receipt, DurableSubmitFailure, InputSchema["EncodingServices"]>;
+  readonly awaitSettlement: (receipt: Receipt) => Effect.Effect<Settlement, DurableAwaitFailure>;
+  /** Authorized, nonblocking read. Only the durable Settlement marks work complete. */
+  readonly submissionStatus: (receipt: Receipt) => Effect.Effect<SubmissionStatus, DurableAwaitFailure>;
+  /**
+   * Trusted worker inspection under the same runtime authority as processThread/recoverSubmission.
+   * Caller-facing observations must use submissionStatus or awaitSettlement for authorization.
+   */
+  readonly inspectSubmissionStatus: (receipt: Receipt) => Effect.Effect<SubmissionStatus, DurableAwaitFailure>;
+  /**
+   * Wait for an already-committed record or one incarnation-local progress hint after
+   * `afterSequence`. Canonical records remain authoritative: callers re-read after return.
+   */
+  readonly awaitProgress: (threadId: ThreadId, afterSequence: CanonicalSequence) => Effect.Effect<void, DurableProgressFailure>;
+  readonly observe: (receipt: Receipt, options?: DurableObserveOptions) => Stream.Stream<CanonicalRecordEnvelope, ThreadStoreError | ThreadNotMaterialized | OperationDenied>;
+  readonly abort: (command: AbortCommand) => Effect.Effect<AbortIntent, DurableAbortFailure>;
+  readonly resolveUnknown: (command: UnknownResolutionCommand) => Effect.Effect<UnknownResolutionIntent, DurableResolveFailure | OperationDenied>;
+  readonly resolveApproval: (command: ApprovalDecisionCommand) => Effect.Effect<ApprovalDecisionIntent, DurableApprovalFailure | OperationDenied>;
+  /**
+   * Read-only recovery explanation of one Submission (P7 plan §3): snapshot + tolerant
+   * canonical read + the pure classifier, packaged with the decision's operator meaning and
+   * predicted disposition. Performs ZERO writes — the canonical log and every ledger row are
+   * byte-identical before and after.
+   */
+  readonly explain: (submissionId: SubmissionId) => Effect.Effect<RecoveryExplanation, DurableExplainFailure>;
+  /** `explain` for every nonterminal lane member of one Thread, in queue order. */
+  readonly explainThread: (threadId: ThreadId) => Effect.Effect<ReadonlyArray<RecoveryExplanation>, DurableExplainFailure>;
+  /**
+   * Read-only integrity verification of one Thread (P7 plan §3): Schema round-trips,
+   * record-identity uniqueness, sequence contiguity, FIFO input/settlement order,
+   * ledger-terminal vs canonical-settlement agreement (DUR-015), and checkpoint binding —
+   * typed per-check results, never a repair. The digest-chain check reports `skipped` with
+   * the honest reason: full chain recomputation needs per-batch producer identity, which the
+   * ThreadStore port deliberately does not export (supply it to
+   * `verifyThreadInvariants` directly; adapter-level `verifyOnOpen` is the
+   * storage-side audit).
+   */
+  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`
+   * for settled work and for lanes owned by the resolveUnknown/resolveApproval paths.
+   */
+  readonly retry: (command: RetryCommand) => Effect.Effect<RecoveryReport, DurableRetryFailure>;
+  /** The documented operator liveness nudge: a droppable wake hint for one lane. */
+  readonly wake: (threadId: ThreadId) => Effect.Effect<void, OperationDenied>;
+  /**
+   * Scan-based DUR-017/OPS-001 obligation report: every nonterminal Submission with what it
+   * is visibly blocked on, its age, and a threshold-classified severity. Never a daemon —
+   * hosts run it periodically and own the alert loop (OPS-002).
+   */
+  readonly scanObligations: (thresholds: ObligationThresholds) => Effect.Effect<ObligationReport, DurableObligationFailure>;
+  readonly processThread: <InputSchema extends Schema.Top, OutputSchema extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, Provider, ModelProvides, ModelRequires, InstructionError = InstructionErrorOf<Instructions, InputSchema["Type"]>, InstructionRequirements = InstructionRequirementsOf<Instructions, InputSchema["Type"]>, RunDispositionValue extends RunDispositionDeclaration<OutputSchema["Type"], Schema.Top> | undefined = undefined, InputPromptValue extends InputPromptSource<InputSchema["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined>(agent: RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, threadId: ThreadId) => Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure, DurableWorkerRequirements<RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, InstructionRequirements>>;
+  readonly processThreadResolved: (threadId: ThreadId) => Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure>;
+  /**
+   * Advance at most one FIFO-head Attempt, closing its resources before returning. A vacant,
+   * owned, unknown, or suspended head returns None and leaves accepted work pending.
+   * Ready input may join this Run through the existing Turn seams and settle with its head.
+   * Interruption ends only this Attempt; ownership cleanup uses its latest renewed token.
+   * A trusted host may supply `yieldAfter` to return None before the next Turn's context
+   * preparation, committing any completed Turn first. This releases ownership without settling or resetting the durable
+   * Run deadline. It is a cooperative scheduling deadline, not a hard interruption timeout.
+   */
+  readonly processThreadHead: (threadId: ThreadId, options?: {
+    readonly yieldAfter?: DateTime.Utc;
+  }) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure | DurableBindingFailure>;
+  readonly runWorker: <InputSchema extends Schema.Top, OutputSchema extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, Provider, ModelProvides, ModelRequires, InstructionError = InstructionErrorOf<Instructions, InputSchema["Type"]>, InstructionRequirements = InstructionRequirementsOf<Instructions, InputSchema["Type"]>, RunDispositionValue extends RunDispositionDeclaration<OutputSchema["Type"], Schema.Top> | undefined = undefined, InputPromptValue extends InputPromptSource<InputSchema["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined>(agent: RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>) => Effect.Effect<void, DurableWorkerFailure | DurableBindingFailure, DurableWorkerRequirements<RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, InstructionRequirements>>;
+  readonly runResolvedWorker: Effect.Effect<void, DurableWorkerFailure | DurableBindingFailure>;
+  readonly runRecovery: Effect.Effect<ReadonlyArray<RecoveryReport>, DurableWorkerFailure>;
+  /** Apply one recovery decision; untouched ready input is deferred to its worker claim. */
+  readonly recoverSubmission: (submissionId: SubmissionId) => Effect.Effect<RecoveryReport, DurableWorkerFailure>;
+}>;
+/**
+ * Durable Agent Runtime coordinator (deployment class DN; D1/D2). It coordinates the
+ * SubmissionLedger, ThreadStore, and WakeScheduler ports so that once `submit` returns a
+ * Receipt, the Submission settles exactly once (DUR-001/DUR-002) while every external effect
+ * remains at-least-once (DUR-003) — this runtime never claims exactly-once side effects.
+ *
+ * - `submit(agent, input, options)` — durable admission → Thread materialization →
+ *   `ThreadCreated` → readiness → Receipt, with failpoints between the steps; a retry with
+ *   the same (thread, principal, idempotencyKey) resumes and returns the same Receipt.
+ * - `awaitSettlement(receipt)` — authorized once before the first ledger read, for the lifetime
+ *   of this wait; interrupting it detaches the caller only and never cancels accepted work.
+ * - `observe(receipt, {after})` — canonical record observation from a stored offset.
+ * - `abort(command)` — authorized before ledger access; durable idempotent abort intent; inactive work settles aborted through
+ *   recovery, an active worker makes the command canonical before interrupting its Run (§13),
+ *   settled work fails with `SettlementConflict` (DUR-012). A `joined` Submission fails with a
+ *   typed `JoinedToHost` conflict carrying the host identity — it settles with its host, so the
+ *   abort target is the host; aborting a `joining` Submission records the intent, honored only
+ *   if the host has not consumed the input (revert-then-abort, plan §2.5).
+ * - `resolveUnknown(command)` — the authorized DUR-017 resolution path for Unknown Outcomes:
+ *   the durable intent is idempotent per (submission, tool call) and conflicts typed on
+ *   divergence; the canonical resolution records are applied by recovery or the next Attempt,
+ *   and the lane wakes once every marked call is covered.
+ * - `resolveApproval(command)` — the durable approval decision path (plan §2.6): the intent is
+ *   idempotent per (submission, tool call) with a typed `ApprovalConflict` on divergence; once
+ *   every pending call of the suspension reason is decided the lane wakes
+ *   (`suspended → input-applied`) and the next Attempt resumes the declared batch without model
+ *   re-invocation, appending the canonical `ToolApprovalDecided` before honoring the decision.
+ * - `processThread(agent, threadId)` — drain one lane: fenced FIFO-head claims,
+ *   canonical input apply, split response/prepared/results Turn commits (plan §2.1),
+ *   reconcile-then-mark for open ordinary Tool Calls (DUR-009, never an automatic replay),
+ *   declared-batch resume without model re-invocation (§15), and terminalization. An active
+ *   host Run claims the contiguous ready prefix of later queued Submissions at every safe Turn
+ *   seam (Joining/Joined, plan §2.5): the queued input becomes canonical (`input:{sid}`) before
+ *   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`.
+ * - `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.
+ * - `runRecovery()` — classify every nonterminal Submission with the pure `classifyRecovery` and
+ *   execute the repair decisions, appending a `RepairAnnotated` audit record per executed decision
+ *   (DUR-013). Untouched ready input and model-resuming work are reported `deferred` for a
+ *   worker claim; lanes blocked 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
+ *   deferred to a claiming worker because it needs the parent Binding's result projection.
+ * - `explain`/`explainThread`, `verify`, `retry`, `wake`, `scanObligations` — the P7
+ *   administrative operations (plan §3) over the same two ports, identical on DN and DC.
+ *   `explain` and `verify` are strictly read-only; `retry` re-drives exactly one classified
+ *   repair with mandatory author/reason audit and typed refusals; `scanObligations` is the
+ *   scan-based DUR-017/OPS-001 obligation surface. Every one of them (plus `observe`,
+ *   `resolveUnknown`, `resolveApproval`) consults the `OperationAuthorizer` reference
+ *   fail-closed — the default Layer preserves the service-possession behavior, and a
+ *   host-supplied authorizer turns denials into the typed `OperationDenied`.
+ */
+declare class DurableAgentRuntime extends DurableAgentRuntime_base {
+  /**
+   * Resolve typed registrations and capture their services once in the runtime's Layer Scope.
+   * Every claimed head must match an exact registered identity and digest triple. 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 | RunToolAuthorization | 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 {
+    readonly agent: infer A extends ExecutableAgentBinding;
+  } ? DurableWorkerRequirements<A> : T extends {
+    readonly agent: infer D extends Definition<Schema.Top, Schema.Top, unknown, import("effect/unstable/ai/Toolkit").Any, RunDispositionDeclaration<never, Schema.Top> | undefined, unknown, Schema.Top | undefined> & {
+      readonly instructions: InstructionSource<never, unknown, unknown>;
+      readonly inputPrompt?: InputPromptSource<never, unknown, unknown> | undefined;
+    };
+    readonly model: infer M extends ExecutableAgentBinding["model"];
+  } ? DurableWorkerRequirements<{
+    readonly definition: D;
+    readonly model: M;
+  }> : never, Provides> : 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/unstable/ai/Toolkit").Any, RunDispositionDeclaration<never, Schema.Top> | undefined, unknown, Schema.Top | undefined> & {
+      readonly instructions: InstructionSource<never, unknown, unknown>;
+      readonly inputPrompt?: InputPromptSource<never, unknown, unknown> | undefined;
+    };
+    readonly model: infer M extends ExecutableAgentBinding["model"];
+  } ? DurableWorkerRequirements<{
+    readonly definition: D;
+    readonly model: M;
+  }> : never : never : never) | ("reporting" extends keyof T ? T[keyof T & "reporting"] extends (infer T_2) ? T_2 extends T[keyof T & "reporting"] ? T_2 extends readonly WorkerReporting<unknown, unknown>[] ? [T_2[number]] extends [never] ? never : T_2[number] extends WorkerReporting<unknown, infer R> ? Exclude<R, Scope.Scope> : never : never : never : never : never) : never : never : never, Scope.Scope>>;
+  /** Construct from precompiled registrations whose captured resources belong to the caller's Scope. */
+  static layerWithBindings(bindings: ReadonlyArray<ResolvedBinding>): Layer.Layer<DurableAgentRuntime, never, Crypto.Crypto | DurableRuntimeConfig | DurableRuntimeFailpoint | RunToolAuthorization | SubmissionLedger | ThreadStore | ToolReconciler | WakeScheduler>;
+  /** Captures optional context preparation; Tool authorization remains required in `R`. */
+  static readonly layerWithServices: Layer.Layer<DurableAgentRuntime, never, SubmissionLedger | ThreadStore | WakeScheduler | DurableRuntimeFailpoint | DurableRuntimeConfig | ToolReconciler | RunToolAuthorization | Crypto.Crypto>;
+  /** Compatible defaults: no host prompt transformation and allow-all Tool authorization. */
+  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, RunCompleted, 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 };
+}
+/** Stable identity of one canonical record. */
+declare const RecordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+type RecordId = typeof RecordId.Type;
+/** Stable idempotency identity of one atomic append. */
+declare const BatchId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/BatchId">;
+type BatchId = typeof BatchId.Type;
+/** Identity of the deployment that produced a record. */
+declare const DeploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+type DeploymentId = typeof DeploymentId.Type;
+/** Identity of a fenced canonical-log producer. */
+declare const ProducerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ProducerId">;
+type ProducerId = typeof ProducerId.Type;
+/** SHA-256 digest encoded as lowercase hexadecimal text. */
+declare const Digest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+type Digest = typeof Digest.Type;
+/** Adapter-owned resume cursor. Callers must not parse or synthesize it. */
+declare const ObservationOffset: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ObservationOffset">;
+type ObservationOffset = typeof ObservationOffset.Type;
+/** Gap-free position in one Thread's canonical sequence. */
+declare const CanonicalSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+type CanonicalSequence = typeof CanonicalSequence.Type;
+/** Monotonic fencing epoch for a Thread producer. */
+declare const ProducerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+type ProducerEpoch = typeof ProducerEpoch.Type;
+/**
+ * The complete generic diagnostic allowed on a failed durable Settlement. It deliberately has
+ * no raw Cause, stack, provider payload, or application-specific fields; those values can carry
+ * secrets and do not form a stable cross-process contract.
+ */
+declare const SettlementFailureDiagnostic: Schema.Struct<{
+  readonly errorTag: Schema.NonEmptyString;
+  readonly message: Schema.String;
+}>;
+type SettlementFailureDiagnostic = typeof SettlementFailureDiagnostic.Type;
+declare const MAX_PERSISTED_JSON_DEPTH = 64;
+declare const MAX_PERSISTED_JSON_COLLECTION_LENGTH = 4096;
+declare const MAX_PERSISTED_JSON_NODES = 65536;
+declare const MAX_PERSISTED_JSON_BYTES: number;
+/** Canonical JSON admitted to persisted records and checkpoints under explicit resource limits. */
+declare const PersistedJson: Schema.declare<Schema.Json, Schema.Json>;
+type PersistedJson = typeof PersistedJson.Type;
+declare const DefinitionDigestInput_base: Schema.Class<DefinitionDigestInput, Schema.Struct<{
+  readonly agent: Schema.declare<Schema.Json, Schema.Json>;
+  readonly model: Schema.declare<Schema.Json, Schema.Json>;
+  readonly tools: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/** Schema-owned replay inputs whose individual definitions are incorporated into digests. */
+declare class DefinitionDigestInput extends DefinitionDigestInput_base {}
+declare const DefinitionDigests_base: Schema.Class<DefinitionDigests, Schema.Struct<{
+  readonly agent: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly model: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly tools: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/** Digests make a replay-visible definition/configuration change explicit. */
+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">;
+  readonly definitions: typeof DefinitionDigests;
+}>, {}>;
+declare class ThreadCreated extends ThreadCreated_base {}
+declare const UserInputRecorded_base: Schema.Class<UserInputRecorded, Schema.TaggedStruct<"UserInputRecorded", {
+  readonly submissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly kind: Schema.Literals<readonly ["user", "steering", "follow-up"]>;
+  readonly runId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly input: Schema.declare<Schema.Json, Schema.Json>;
+  readonly messageAdmission: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly peerName: Schema.NonEmptyString;
+    readonly sender: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly returnAddress: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>>;
+  }>, Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerCompletion">;
+    readonly budgetExhausted: Schema.Boolean;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly report: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literal<"completed">;
+      readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+      readonly failure: typeof SubagentExecutionFailure;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerUpdate">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly update: typeof Update;
+  }>]>]>>;
+}>, {}>;
+/**
+ * One recorded Thread input. `submissionId` is present only for durably accepted work;
+ * retained history has no admission or settlement obligation. `kind` identifies the input seam.
+ */
+declare class UserInputRecorded extends UserInputRecorded_base {}
+declare const RunStartedRecord_base: Schema.Class<RunStartedRecord, Schema.TaggedStruct<"RunStarted", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  /** Older private histories cannot prove programmatic accounting and must be reset. */
+  readonly policyAccountingVersion: Schema.Literal<1>;
+  readonly maxDurationMillis: Schema.Finite;
+}>, {}>;
+/** Immutable clock and duration allowance for one logical Run, before any agent execution. */
+declare class RunStartedRecord extends RunStartedRecord_base {}
+declare const ModelCompleted_base: Schema.Class<ModelCompleted, Schema.Struct<{
+  readonly _tag: Schema.tag<"ModelCompleted">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly output: Schema.declare<Schema.Json, Schema.Json>;
+  readonly messages: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+}>, {}>;
+/**
+ * Final model output. Immediate history may include the exact encoded Prompt suffix of the
+ * successful Run; durable execution instead journals individual ModelResponseRecorded Turns.
+ */
+declare class ModelCompleted extends ModelCompleted_base {}
+declare const ToolCallSettled_base: Schema.Class<ToolCallSettled, Schema.TaggedStruct<"ToolCallSettled", {
+  readonly toolSelection: Schema.optionalKey<typeof Selection>;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly result: Schema.declare<Schema.Json, Schema.Json>;
+  readonly isFailure: Schema.Boolean;
+  /** Explicit engine evidence, never inferred from Tool result data. */
+  readonly budgetRejected: Schema.optionalKey<Schema.Literal<true>>;
+}>, {}>;
+declare class ToolCallSettled extends ToolCallSettled_base {}
+declare const ModelResponseRecorded_base: Schema.Class<ModelResponseRecorded, Schema.Struct<{
+  readonly _tag: Schema.tag<"ModelResponseRecorded">;
+  readonly toolExposure: Schema.optionalKey<typeof Snapshot>;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly messages: Schema.declare<Schema.Json, Schema.Json>;
+  readonly messagesDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly runScopedPrefixLength: Schema.optionalKey<Schema.Int>;
+  readonly modelUsage: Schema.optionalKey<Schema.$Array<typeof ModelCallUsage>>;
+  readonly unobservedModelCalls: Schema.optionalKey<Schema.Natural>;
+  readonly inputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly outputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly costMicrousd: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+declare class ModelResponseRecorded extends ModelResponseRecorded_base {}
+declare const ToolCallPrepared_base: Schema.Class<ToolCallPrepared, Schema.TaggedStruct<"ToolCallPrepared", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+  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"]>>;
+}>, {}>;
+/**
+ * One approved uncertain/idempotent ordinary Tool Call made durable BEFORE any handler starts
+ * (durability §10). `parameters` is the Schema-encoded wire form of the declared call and
+ * `parametersDigest` pins it; recovery that sees this record without a matching `ToolCallSettled`
+ * (or `ToolCallUnknown` → `ToolCallResolved`) must reconcile or mark unknown, never silently
+ * replay (DUR-009). Ordinary `readonly`-class Tools never produce this record. Delegation
+ * classification is always prepared, including for a Tool annotated `readonly`.
+ */
+declare class ToolCallPrepared extends ToolCallPrepared_base {}
+declare const RunPolicyUsageReserved_base: Schema.Class<RunPolicyUsageReserved, Schema.TaggedStruct<"RunPolicyUsageReserved", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly programmaticToolCalls: Schema.Natural;
+  readonly finalizationUsed: Schema.Boolean;
+}>, {}>;
+/** Monotonic reservations charged before programmatic execution or grace finalization. */
+declare class RunPolicyUsageReserved extends RunPolicyUsageReserved_base {}
+declare const ToolCallUnknown_base: Schema.Class<ToolCallUnknown, Schema.TaggedStruct<"ToolCallUnknown", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * A durable Unknown Outcome: the external effect of one prepared ordinary Tool Call may have
+ * happened but was not confirmed canonically (DUR-009/DUR-017). It is neither success nor
+ * ordinary failure; automatic continuation stops until an authorized resolution arrives.
+ */
+declare class ToolCallUnknown extends ToolCallUnknown_base {}
+/** How one open/unknown Tool Call was authoritatively closed (DUR-017 resolution audit). */
+declare const ToolCallResolution: Schema.Literals<readonly ["completed-with-result", "failed-with-error", "never-started", "safe-retry"]>;
+type ToolCallResolution = typeof ToolCallResolution.Type;
+declare const ToolCallResolved_base: Schema.Class<ToolCallResolved, Schema.TaggedStruct<"ToolCallResolved", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly resolution: Schema.Literals<readonly ["completed-with-result", "failed-with-error", "never-started", "safe-retry"]>;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * The canonical audit record closing one open or unknown Tool Call: reconciler-recovered supplier
+ * truth or an authorized `resolveUnknown` command. `author`/`reason` make every resolution an
+ * attributable decision (DUR-017); a `completed-with-result` resolution is accompanied by the
+ * per-call `ToolCallSettled` record carrying the recovered result.
+ */
+declare class ToolCallResolved extends ToolCallResolved_base {}
+declare const ToolStepSettled_base: Schema.Class<ToolStepSettled, Schema.TaggedStruct<"ToolStepSettled", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly stepName: Schema.NonEmptyString;
+  readonly output: Schema.declare<Schema.Json, Schema.Json>;
+  readonly outputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/**
+ * One accepted Durable Step result (durability §11): exactly-once-recorded while the Step's
+ * external side effect stays honestly at-least-once-executed. Only success is recorded — a failing
+ * Step body fails into the handler's error channel and re-executes on re-entry. `output` is the
+ * Schema-encoded Step output; `outputDigest` pins it for replay-divergence detection.
+ */
+declare class ToolStepSettled extends ToolStepSettled_base {}
+declare const ToolApprovalRequested_base: Schema.Class<ToolApprovalRequested, Schema.TaggedStruct<"ToolApprovalRequested", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly parametersDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/**
+ * A canonical approval request for one declared Tool Call (CAP-006, durability §8): with this
+ * record durable, "waiting for explicit approval" is a safe suspension boundary — the resumed
+ * Attempt replays the declared batch instead of re-invoking the model.
+ */
+declare class ToolApprovalRequested extends ToolApprovalRequested_base {}
+/** The two-valued approval decision family shared by canonical records and ledger intents. */
+declare const ApprovalDecision: Schema.Literals<readonly ["approved", "denied"]>;
+type ApprovalDecision = typeof ApprovalDecision.Type;
+declare const ToolApprovalDecided_base: Schema.Class<ToolApprovalDecided, Schema.TaggedStruct<"ToolApprovalDecided", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly decision: Schema.Literals<readonly ["approved", "denied"]>;
+  readonly resolver: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * The canonical decision for one requested approval. Appended by the deciding Attempt (policy
+ * auto-decisions) or by the resuming Attempt after a durable `resolveApproval` intent; it is the
+ * deterministic decision authority for every later Attempt of the same Run.
+ */
+declare class ToolApprovalDecided extends ToolApprovalDecided_base {}
+declare const ModelResponseInterrupted_base: Schema.Class<ModelResponseInterrupted, Schema.TaggedStruct<"ModelResponseInterrupted", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly supersededEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+  readonly attemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * First-class interruption audit (durability §9): appended by a superseding Attempt before it
+ * re-invokes the model for a Turn whose prior owner died without a complete canonical response.
+ * Duplicate provider cost is thereby possible AND observable in canonical history.
+ */
+declare class ModelResponseInterrupted extends ModelResponseInterrupted_base {}
+declare const CompactionCreated_base: Schema.Class<CompactionCreated, Schema.TaggedStruct<"CompactionCreated", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turn: Schema.Int;
+  readonly kind: Schema.Literals<readonly ["clear-tool-results", "summarize", "rollover"]>;
+  readonly coversThrough: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly summary: Schema.optionalKey<Schema.String>;
+  readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/**
+ * One engine-native compaction committed before the pre-Turn view changes (RUN-026).
+ * `coversThrough` is a Thread record sequence: the projection
+ * renders records at or below it as a summary (`summarize`), a fresh window (`rollover`), or with
+ * cleared tool results (kind `clear-tool-results`), never erasing source
+ * history. The record carries no digest by decision: it is appended by the
+ * fenced owner into the very log it covers, and re-verifying a digest would
+ * re-read the covered range on every wake — the O(history) work compaction
+ * exists to remove. Host-supplied ContextCompactor decisions use this same commit path.
+ * Summaries exceeding BoundedText are rejected before append, never truncated.
+ * `summary` is present exactly for `summarize` records; the projection
+ * treats a summarize record without one as invalid and ignores it fail-safe.
+ */
+declare class CompactionCreated extends CompactionCreated_base {}
+declare const RunFailed_base: Schema.Class<RunFailed, Schema.TaggedStruct<"RunFailed", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly failure: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+declare class RunFailed extends RunFailed_base {}
+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 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"]>>;
+}>, {}>;
+declare class RunCompleted extends RunCompleted_base {}
+declare const RepairAnnotated_base: Schema.Class<RepairAnnotated, Schema.TaggedStruct<"RepairAnnotated", {
+  readonly reason: Schema.String;
+  readonly details: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+declare class RepairAnnotated extends RepairAnnotated_base {}
+/** Terminal outcome family for one accepted Submission (DUR-002). */
+declare const SettlementOutcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+type SettlementOutcome = typeof SettlementOutcome.Type;
+declare const AbortRequested_base: Schema.Class<AbortRequested, Schema.TaggedStruct<"AbortRequested", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * A durable abort command made canonical before the active worker is interrupted (DUR-012).
+ * Repeating the same abort command is idempotent; abort never rewrites a prior terminal outcome.
+ */
+declare class AbortRequested extends AbortRequested_base {}
+declare const SubmissionSettled_base: Schema.Class<SubmissionSettled, Schema.Struct<{
+  readonly _tag: Schema.tag<"SubmissionSettled">;
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  readonly runId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly result: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  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"]>>;
+  readonly policyLimit: Schema.optionalKey<Schema.Literals<readonly ["turns", "tool-calls", "duration", "usage", "tokens", "cost", "repeated-failures"]>>;
+  readonly usageSummary: Schema.optionalKey<typeof RunUsageSummary>;
+  readonly uncommittedModelUsage: Schema.optionalKey<Schema.$Array<typeof ModelCallUsage>>;
+}>, {}>;
+declare class SubmissionSettled extends SubmissionSettled_base {}
+/** Canonical completed settlement; joined completion may legitimately carry no independent result. */
+type CompletedSubmissionSettled = SubmissionSettled & {
+  readonly outcome: "completed";
+};
+/** Canonical failed settlement; its bounded diagnostic is required and typed. */
+type FailedSubmissionSettled = SubmissionSettled & {
+  readonly outcome: "failed";
+  readonly result: SettlementFailureDiagnostic;
+};
+/** Canonical aborted settlement; abort records intent rather than fabricating a terminal result. */
+type AbortedSubmissionSettled = SubmissionSettled & {
+  readonly outcome: "aborted";
+  readonly result?: never;
+};
+type SubmissionSettledRecord = CompletedSubmissionSettled | FailedSubmissionSettled | AbortedSubmissionSettled;
+/**
+ * Canonical-boundary view of `SubmissionSettled`: `finishReason` is valid
+ * only on a `completed` outcome, `exhausted` only alongside
+ * `finishReason: "budget-exhausted"`, every `failed` outcome requires the exact bounded
+ * `SettlementFailureDiagnostic`, aborted outcomes carry no result, and `policyLimit` only occurs
+ * on a `failed` outcome whose diagnostic carries the `AgentPolicyError` tag. `runDisposition`
+ * occurs only on an ordinary completed settlement with a Run —
+ * so a malformed persisted combination such as
+ * `{ outcome: "failed", finishReason: "budget-exhausted" }` or a
+ * `policyLimit` contradicting `result.errorTag` fails closed at decode
+ * instead of becoming trusted audit history (STORE-006, RUN-011).
+ */
+declare const SubmissionSettledRecord: Schema.refine<SubmissionSettledRecord, typeof SubmissionSettled>;
+declare const SubagentRequested_base: Schema.Class<SubagentRequested, Schema.TaggedStruct<"SubagentRequested", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly targetDigests: typeof DefinitionDigests;
+  readonly childInput: Schema.declare<Schema.Json, Schema.Json>;
+  readonly childInputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly grantDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly reservationId: Schema.NonEmptyString;
+  readonly reservationDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly childPrincipal: Schema.NonEmptyString;
+  readonly childIdempotencyKey: Schema.NonEmptyString;
+  /** Effective invocation bound, already clamped to the delegation and child Definition. */
+  readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+  readonly policy: Schema.optionalKey<Schema.toCodecJson<typeof AgentPolicy>>;
+  readonly budget: Schema.optionalKey<Schema.Struct<{
+    readonly caps: typeof SubagentDelegationCaps;
+    readonly allocation: typeof SubagentReservationAmounts;
+    readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  }>>;
+  readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+  readonly depth: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/**
+ * PARENT-log record of one durable child establishment request:
+ * the exact parent Tool Call, delegation and target identity, the digests that pin the child's
+ * Binding/input/grant, the fenced budget reservation, and the INTENDED child identity derived
+ * deterministically from the parent Run and Tool Call pair (D4). `childInput` carries the
+ * prepared child input in encoded form (D3) so recovery can complete child admission from this
+ * record alone — no live delegation handler is required. `childPrincipal`/`childIdempotencyKey`
+ * carry the ledger admission scope with the ledger's exact bounds; the layering keeps their
+ * branded Schemas in the ledger port.
+ */
+declare class SubagentRequested extends SubagentRequested_base {}
+declare const SubagentStarted_base: Schema.Class<SubagentStarted, Schema.TaggedStruct<"SubagentStarted", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childReceiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly childRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+}>, {}>;
+/**
+ * PARENT-log record that the intended child exists as accepted work:
+ * the full established child identity. It is appended only after the child Receipt
+ * exists — SUB-017 holds by construction because `childReceiptId` is a required field.
+ */
+declare class SubagentStarted extends SubagentStarted_base {}
+declare const SubagentJoined_base: Schema.Class<SubagentJoined, Schema.TaggedStruct<"SubagentJoined", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childSettlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly childOutcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  readonly childResultDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly projectedResultDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly usageSummary: Schema.declare<Schema.Json, Schema.Json>;
+  readonly usage: Schema.optionalKey<typeof RunTotals>;
+  readonly delegatedUsage: Schema.optionalKey<typeof RunTotals>;
+  readonly reservationId: Schema.NonEmptyString;
+  readonly finalAccounting: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/**
+ * PARENT-log record of one verified child settlement join:
+ * the child's canonical Settlement identity and outcome, the digests pinning the verified child
+ * result and the bounded projected parent result, the child usage summary, and the FINAL
+ * consumed/released accounting decision for the reservation. It commits in ONE atomic batch with
+ * the parent `ToolCallSettled` record (SUB-019); `beginChildBudgetRelease` replays
+ * `finalAccounting` from this record, so canonical history authorizes the release (DUR-015).
+ */
+declare class SubagentJoined extends SubagentJoined_base {}
+declare const SubagentLineageRecorded_base: Schema.Class<SubagentLineageRecorded, Schema.TaggedStruct<"SubagentLineageRecorded", {
+  readonly parentLink: typeof SubagentParentLink;
+  readonly parentSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childDefinitionDigests: typeof DefinitionDigests;
+  readonly childInputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly grantDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  /** Copied from the canonical request before readiness; restored for every child Attempt. */
+  readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+  readonly policy: Schema.optionalKey<Schema.toCodecJson<typeof AgentPolicy>>;
+  readonly budget: Schema.optionalKey<Schema.Struct<{
+    readonly caps: typeof SubagentDelegationCaps;
+    readonly allocation: typeof SubagentReservationAmounts;
+    readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  }>>;
+  readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+}>, {}>;
+/**
+ * CHILD-log immutable lineage: the Parent Link plus the digests that pin
+ * the child's definition, input, and authority grant. It is the first record after the child's
+ * `ThreadCreated` (its own single-record batch, so the generic `thread-created:{cid}`
+ * batch identity is never contradicted) and the join path verifies it fail-closed — a fabricated
+ * child or parent identity fails Parent Link verification (SUB-004, D10).
+ */
+declare class SubagentLineageRecorded extends SubagentLineageRecorded_base {}
+declare const WorkerReportingIntent: Schema.Struct<{
+  /** Omitted preserves existing application-mapped reports. */
+  readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+  readonly sourceDigests: typeof DefinitionDigests;
+  readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+}>;
+/** Immutable worker Thread origin. Each input has its own digest and parameters separately. */
+declare const WorkerOrigin: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly source: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"tool">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"programmatic">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>]>;
+  /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+  readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+  readonly targetDigests: typeof DefinitionDigests;
+  readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+  readonly budget: Schema.Struct<{
+    readonly caps: typeof SubagentDelegationCaps;
+    readonly allocation: typeof SubagentReservationAmounts;
+    readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  }>;
+  readonly grant: typeof SubagentGrant;
+  readonly depth: Schema.Int;
+  readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+  readonly firstMessageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly createdAtMillis: Schema.Natural;
+  readonly expiresAtMillis: Schema.Natural;
+  /** Exact source registration owns projection; absence means reporting was not declared. */
+  readonly reporting: Schema.optionalKey<Schema.Struct<{
+    /** Omitted preserves existing application-mapped reports. */
+    readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+    readonly sourceDigests: typeof DefinitionDigests;
+    readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+  }>>;
+}>;
+type WorkerOrigin = typeof WorkerOrigin.Type;
+/** Frozen per-input metadata; it grants no attached-child or parent-abort semantics. */
+declare const WorkerAdmission: Schema.Struct<{
+  readonly origin: Schema.Struct<{
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"tool">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"programmatic">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>]>;
+    /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+    readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+    readonly targetDigests: typeof DefinitionDigests;
+    readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+    readonly budget: Schema.Struct<{
+      readonly caps: typeof SubagentDelegationCaps;
+      readonly allocation: typeof SubagentReservationAmounts;
+      readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+    }>;
+    readonly grant: typeof SubagentGrant;
+    readonly depth: Schema.Int;
+    readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+    readonly firstMessageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly createdAtMillis: Schema.Natural;
+    readonly expiresAtMillis: Schema.Natural;
+    /** Exact source registration owns projection; absence means reporting was not declared. */
+    readonly reporting: Schema.optionalKey<Schema.Struct<{
+      /** Omitted preserves existing application-mapped reports. */
+      readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+      readonly sourceDigests: typeof DefinitionDigests;
+      readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+    }>>;
+  }>;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+  readonly createdAtMillis: Schema.Natural;
+  /** Host-bound source input whose subtree funds this input; never chosen by a model. */
+  readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  /** Enables routed receipt lookup when the delivery is owned by a reporting child. */
+  readonly deliveryPrincipal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+  /** Proven framework updates use a separate bounded input-capacity partition. */
+  readonly reportKind: Schema.optionalKey<Schema.Literal<"update">>;
+}>;
+type WorkerAdmission = typeof WorkerAdmission.Type;
+declare const WorkerInputRequested_base: Schema.Class<WorkerInputRequested, Schema.TaggedStruct<"WorkerInputRequested", {
+  readonly admission: Schema.Struct<{
+    readonly origin: Schema.Struct<{
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"tool">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+        readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+      }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"programmatic">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>]>;
+      /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+      readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+      readonly targetDigests: typeof DefinitionDigests;
+      readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+      readonly budget: Schema.Struct<{
+        readonly caps: typeof SubagentDelegationCaps;
+        readonly allocation: typeof SubagentReservationAmounts;
+        readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+      }>;
+      readonly grant: typeof SubagentGrant;
+      readonly depth: Schema.Int;
+      readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+      readonly firstMessageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+      readonly createdAtMillis: Schema.Natural;
+      readonly expiresAtMillis: Schema.Natural;
+      /** Exact source registration owns projection; absence means reporting was not declared. */
+      readonly reporting: Schema.optionalKey<Schema.Struct<{
+        /** Omitted preserves existing application-mapped reports. */
+        readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+        readonly sourceDigests: typeof DefinitionDigests;
+        readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+      }>>;
+    }>;
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+    readonly createdAtMillis: Schema.Natural;
+    /** Host-bound source input whose subtree funds this input; never chosen by a model. */
+    readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+    /** Enables routed receipt lookup when the delivery is owned by a reporting child. */
+    readonly deliveryPrincipal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+    /** Proven framework updates use a separate bounded input-capacity partition. */
+    readonly reportKind: Schema.optionalKey<Schema.Literal<"update">>;
+  }>;
+  readonly inputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/** Source-log capacity reservation, retained independently of the source Run's settlement. */
+declare class WorkerInputRequested extends WorkerInputRequested_base {}
+declare const WorkerOriginRecorded_base: Schema.Class<WorkerOriginRecorded, Schema.TaggedStruct<"WorkerOriginRecorded", {
+  readonly origin: Schema.Struct<{
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"tool">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"programmatic">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>]>;
+    /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+    readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+    readonly targetDigests: typeof DefinitionDigests;
+    readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+    readonly budget: Schema.Struct<{
+      readonly caps: typeof SubagentDelegationCaps;
+      readonly allocation: typeof SubagentReservationAmounts;
+      readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+    }>;
+    readonly grant: typeof SubagentGrant;
+    readonly depth: Schema.Int;
+    readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+    readonly firstMessageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly createdAtMillis: Schema.Natural;
+    readonly expiresAtMillis: Schema.Natural;
+    /** Exact source registration owns projection; absence means reporting was not declared. */
+    readonly reporting: Schema.optionalKey<Schema.Struct<{
+      /** Omitted preserves existing application-mapped reports. */
+      readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+      readonly sourceDigests: typeof DefinitionDigests;
+      readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+    }>>;
+  }>;
+}>, {}>;
+/** Child-log origin, reconstructed from a retained delivery before the child becomes ready. */
+declare class WorkerOriginRecorded extends WorkerOriginRecorded_base {}
+declare const WorkerInputCompleted_base: Schema.Class<WorkerInputCompleted, Schema.TaggedStruct<"WorkerInputCompleted", {
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly workerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly completedAtMillis: Schema.Natural;
+}>, {}>;
+/** Canonical child completion acknowledgement releases only this input's active capacity. */
+declare class WorkerInputCompleted extends WorkerInputCompleted_base {}
+declare const WorkerReportPrepared_base: Schema.Class<WorkerReportPrepared, Schema.TaggedStruct<"WorkerReportPrepared", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly envelope: Schema.declare<Schema.Json, Schema.Json>;
+  readonly createdAtMillis: Schema.Natural;
+  readonly deadlineAtMillis: Schema.Natural;
+  readonly predecessor: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">>;
+}>, {}>;
+/**
+ * Frozen report decision for one actual Run, shared by every joined Receipt. The envelope is
+ * a Schema-encoded PreparedInput, validated before append and decoded again on recovery.
+ * Keeping the encoded value here avoids a Records/PreparedInput schema dependency cycle.
+ */
+declare class WorkerReportPrepared extends WorkerReportPrepared_base {}
+declare const AgentUpdateEmitted_base: Schema.Class<AgentUpdateEmitted, Schema.TaggedStruct<"AgentUpdateEmitted", {
+  readonly update: typeof Update;
+  readonly definitions: typeof DefinitionDigests;
+  readonly delivery: Schema.optionalKey<Schema.Struct<{
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly envelope: Schema.declare<Schema.Json, Schema.Json>;
+    readonly createdAtMillis: Schema.Natural;
+    readonly deadlineAtMillis: Schema.Natural;
+    readonly predecessor: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">>;
+  }>>;
+}>, {}>;
+/** Accepted update and its optional frozen parent delivery are one atomic canonical fact. */
+declare class AgentUpdateEmitted extends AgentUpdateEmitted_base {}
+declare const WorkerReportRefused_base: Schema.Class<WorkerReportRefused, Schema.TaggedStruct<"WorkerReportRefused", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly reason: Schema.Literals<readonly ["declaration-unavailable", "destination", "projection", "input", "preparation", "timeout", "defect", "expired", "denied", "capacity"]>;
+}>, {}>;
+/** Permanent bounded report refusal. Application errors and raw Run dispositions stay private. */
+declare class WorkerReportRefused extends WorkerReportRefused_base {}
+declare const PeerMessagePrepared_base: Schema.Class<PeerMessagePrepared, Schema.TaggedStruct<"PeerMessagePrepared", {
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly sourcePrincipal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+  readonly operation: Schema.Literals<readonly ["send", "reply"]>;
+  readonly deadlineAtMillis: Schema.Int;
+  readonly encodedEnvelope: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/** Frozen source proof of peer provenance, readable through routed canonical storage. */
+declare class PeerMessagePrepared extends PeerMessagePrepared_base {}
+declare const SubtreeBudgetReserved_base: Schema.Class<SubtreeBudgetReserved, Schema.TaggedStruct<"SubtreeBudgetReserved", {
+  readonly reservationId: Schema.NonEmptyString;
+  readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly lifetime: Schema.Literals<readonly ["attached", "background"]>;
+  readonly depth: Schema.Int;
+  readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+  readonly grant: typeof SubagentGrant;
+  readonly budget: Schema.Struct<{
+    readonly caps: typeof SubagentDelegationCaps;
+    readonly allocation: typeof SubagentReservationAmounts;
+    readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  }>;
+}>, {}>;
+/**
+ * One disjoint subtree slice shared by attached and background children of a source input.
+ * The source keeps its own execution ceiling; descendants spend only the remaining allocation.
+ * Reservations include future descendant slots and never refund, including after interruption.
+ * resultBytes reserves the terminal/projection result, not cumulative Tool output bytes.
+ */
+declare class SubtreeBudgetReserved extends SubtreeBudgetReserved_base {}
+/**
+ * Current private-development canonical payload family. Phase 5 adds the seven durable-Tool tags
+ * (prepared/unknown/resolved/step/approval-request/approval-decision/interrupted) additively; S2
+ * adds the four durable-Subagent tags (requested/started/joined/lineage) additively, so the
+ * envelope keeps `schemaVersion: 1` (P4 precedent for additive payload tags).
+ */
+declare const CanonicalRecordPayload: Schema.Union<readonly [typeof ThreadCreated, typeof UserInputRecorded, typeof RunStartedRecord, typeof RunPolicyUsageReserved, typeof ModelCompleted, typeof ModelResponseRecorded, typeof ToolCallPrepared, typeof ToolCallSettled, typeof ToolCallUnknown, typeof ToolCallResolved, typeof ToolStepSettled, typeof ToolApprovalRequested, typeof ToolApprovalDecided, typeof ModelResponseInterrupted, typeof CompactionCreated, typeof RunFailed, typeof RunCompleted, typeof AbortRequested, Schema.refine<SubmissionSettledRecord, typeof SubmissionSettled>, typeof SubagentRequested, typeof SubagentStarted, typeof SubagentJoined, typeof SubagentLineageRecorded, typeof WorkerInputRequested, typeof WorkerOriginRecorded, typeof WorkerInputCompleted, typeof WorkerReportPrepared, typeof AgentUpdateEmitted, typeof WorkerReportRefused, typeof PeerMessagePrepared, typeof SubtreeBudgetReserved, typeof RepairAnnotated]>;
+type CanonicalRecordPayload = typeof CanonicalRecordPayload.Type;
+declare const RecordEnvelope_base: Schema.Class<RecordEnvelope, Schema.Struct<{
+  readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+  readonly family: Schema.Literal<"thread">;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+  readonly payload: Schema.Union<readonly [typeof ThreadCreated, typeof UserInputRecorded, typeof RunStartedRecord, typeof RunPolicyUsageReserved, typeof ModelCompleted, typeof ModelResponseRecorded, typeof ToolCallPrepared, typeof ToolCallSettled, typeof ToolCallUnknown, typeof ToolCallResolved, typeof ToolStepSettled, typeof ToolApprovalRequested, typeof ToolApprovalDecided, typeof ModelResponseInterrupted, typeof CompactionCreated, typeof RunFailed, typeof RunCompleted, typeof AbortRequested, Schema.refine<SubmissionSettledRecord, typeof SubmissionSettled>, typeof SubagentRequested, typeof SubagentStarted, typeof SubagentJoined, typeof SubagentLineageRecorded, typeof WorkerInputRequested, typeof WorkerOriginRecorded, typeof WorkerInputCompleted, typeof WorkerReportPrepared, typeof AgentUpdateEmitted, typeof WorkerReportRefused, typeof PeerMessagePrepared, typeof SubtreeBudgetReserved, typeof RepairAnnotated]>;
+}>, {}>;
+/**
+ * Versioned record envelope stored in an atomic batch. Thread ordering is assigned only
+ * when the batch is committed.
+ */
+declare class RecordEnvelope extends RecordEnvelope_base {}
+/** Backward-compatible domain name for a canonical record. */
+declare const CanonicalRecord: typeof RecordEnvelope;
+type CanonicalRecord = RecordEnvelope;
+declare const CanonicalBatch_base: Schema.Class<CanonicalBatch, Schema.Struct<{
+  readonly batchId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/BatchId">;
+  readonly producerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ProducerId">;
+  readonly records: Schema.NonEmptyArray<typeof RecordEnvelope>;
+}>, {}>;
+/** One non-empty, bounded, idempotent atomic append unit. */
+declare class CanonicalBatch extends CanonicalBatch_base {}
+declare const CanonicalRecordEnvelope_base: Schema.Class<CanonicalRecordEnvelope, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly batchId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/BatchId">;
+  readonly sequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly offset: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ObservationOffset">;
+  readonly record: typeof RecordEnvelope;
+}>, {}>;
+/**
+ * A committed record with its Thread ordering and opaque resumable observation cursor.
+ */
+declare class CanonicalRecordEnvelope extends CanonicalRecordEnvelope_base {}
+declare const CURRENT_CANONICAL_SCHEMA_VERSION: 1;
+//#endregion
+export { ToolCallResolved as $, UnknownResolution as $a, ChildBudgetReservationSnapshot as $i, turnBatchId as $n, AwaitChildAdmissionResolution as $r, ThreadObservation as $t, ProducerId as A, ResolutionAbortSubmission as Aa, SettleJoinedWithHost as Ai, runCompletedRecordId as An, AgentRegistration_d_exports as Ar, DurableWorkerFailure as At, SettlementOutcome as B, SubmissionAdmissionFence as Ba, AdmissionNotAdmitted as Bi, subagentStartedBatchId as Bn, definitionDigestsEqual as Br, CheckpointRejected as Bt, ModelCompleted as C, RecoverySnapshot as Ca, RepairSubagentStartLink as Ci, markUnknownBatchId as Cn, RetryCommand as Cr, DurableRetryFailure as Ct, PeerMessagePrepared as D, RenewOwnershipRequest as Da, ResumeWaitingParent as Di, projectRunJournal as Dn, predictRecoveryDisposition as Dr, DurableSubmitFailure as Dt, ObservationOffset as E, ReleaseOwnershipRequest as Ea, ResumeSuspended as Ei, modelResponseRecordId as En, obligationSeverityOf as Er, DurableSubmitAgent as Et, RunCompleted as F, Settlement as Fa, AdmissionAdmitted as Fi, subagentJoinedRecordId as Fn, DurableBindingFailure as Fr, recoveryRepairRecordId as Ft, SubmissionSettled as G, SubmissionLookupById as Ga, ApprovalConflict as Gi, toolCallResolutionBatchId as Gn, digestDefinition as Gr, SaveCheckpointRequest as Gt, SubagentLineageRecorded as H, SubmissionLedgerFailure as Ha, AdmissionRequest as Hi, toolApprovalDecisionRecordId as Hn, Digest_d_exports as Hr, FencedAppendRequest as Ht, RunFailed as I, SettlementConflict as Ia, AdmissionConflict as Ii, subagentLineageBatchId as In, DurableWorkerBinding as Ir, threadCreatedBatchId as It, ThreadCreated as J, SubmissionState as Ja, ApprovalPendingSuspension as Ji, toolCallSettledRecordId as Jn, AppendReservedSettlement as Jr, ThreadCheckpoints as Jt, SubmissionSettledRecord as K, SubmissionLookupByKey as Ka, ApprovalDecisionCommand as Ki, toolCallResolvedRecordId as Kn, digestDefinitions as Kr, SaveRecoveryCheckpointRequest as Kt, RunPolicyUsageReserved as L, SettlementFinalization as La, AdmissionFence as Li, subagentLineageRecordId as Ln, ExecutableAgentBinding as Lr, threadCreatedRecordId as Lt, RecordId as M, ResolutionNeverHappened as Ma, AbortCommand as Mi, runStartedBatchId as Mn, AgentRegistration as Mr, RecoveryReport as Mt, Records_d_exports as N, ResolutionSafeToRetry as Na, AbortIntent as Ni, runStartedRecordId as Nn, BindingDigestMismatch as Nr, childReservationIdFor as Nt, PersistedJson as O, ReservedChildBudget as Oa, RevertJoining as Oi, projectRunJournalStream as On, recoveryDecisionMeaning as Or, DurableSubmitOptions as Ot, RepairAnnotated as P, RevertJoiningRequest as Pa, AbortIntentRequest as Pi, subagentJoinBatchId as Pn, BindingUnavailable as Pr, recoveryRepairBatchId as Pt, ToolCallResolution as Q, SuspensionSnapshot as Qa, ChildBudgetReservationRequest as Qi, turnApprovalsBatchId as Qn, AwaitApprovalDecision as Qr, ThreadNotMaterialized as Qt, RunStartedRecord as R, SettlementReservation as Ra, AdmissionGroup as Ri, subagentRequestedBatchId as Rn, ResolvedBinding as Rr, AppendConflict as Rt, MAX_PERSISTED_JSON_NODES as S, ParentLinkage as Sa, RepairReadiness as Si, compactionRecordId as Sn, RecoveryExplanation as Sr, DurableResolveFailure as St, ModelResponseRecorded as T, ReleaseChildBudgetRequest as Ta, ResumePendingToolBatch as Ti, modelResponseInterruptedRecordId as Tn, RetryRefused as Tr, DurableRuntimeConfigOptions as Tt, SubagentRequested as U, SubmissionLedger_d_exports as Ua, AdmissionResolution as Ui, toolApprovalRequestRecordId as Un, EMPTY_TAIL_DIGEST as Ur, LoadCheckpointRequest as Ut, SubagentJoined as V, SubmissionLedger as Va, AdmissionPolicyError as Vi, subagentStartedRecordId as Vn, DigestError as Vr, FenceRejected as Vt, SubagentStarted as W, SubmissionLookup as Wa, AdmissionResult as Wi, toolCallPreparedRecordId as Wn, digestCanonicalBatch as Wr, MAX_THREAD_EXPORT_RECORDS as Wt, ToolApprovalRequested as X, SuspensionOutcome as Xa, BeginChildBudgetReleaseRequest as Xi, toolStepSettledBatchId as Xn, ApplyJoinAccounting as Xr, ThreadExportRequest as Xt, ToolApprovalDecided as Y, SuspendRequest as Ya, AttachChildToReservationRequest as Yi, toolCallUnknownRecordId as Yn, ApplyInput as Yr, ThreadExport as Yt, ToolCallPrepared as Z, SuspensionReason as Za, ChildAttachmentSnapshot as Zi, toolStepSettledRecordId as Zn, ApplyUnknownResolutions as Zr, ThreadMaterialization as Zt, Digest as _, MarkUnknownRequest as _a, RecoveryEvidence as _i, TurnCommitInput as _n, ObligationReport as _r, DurableAwaitFailure as _t, BatchId as a, Claim as aa, CompleteMaterialization as ai, ThreadStore_d_exports as an, settlementFailureFromRecord as ao, turnResultsBatch as ar, WorkerInputCompleted as at, MAX_PERSISTED_JSON_COLLECTION_LENGTH as b, OwnershipSnapshot as ba, RepairInputMarker as bi, childThreadIdFor as bn, RECOVERY_DECISION_MEANINGS as br, DurableObserveOptions as bt, CanonicalRecord as c, DEFAULT_OWNERSHIP_LEASE_DURATION as ca, EnsureWaitingForChild as ci, PendingSubmission as cn, submissionInputBatchId as co, ExplainedEvidence as cr, WorkerOriginRecorded as ct, CanonicalSequence as d, JoiningClaim as da, NoAction as di, SubmissionStatus_d_exports as dn, submissionSettlementId as do, IntegrityCheck as dr, WorkerReportingIntent as dt, ChildReservationConflict as ea, AwaitChildSettlement as ei, ThreadRead as en, UnknownResolutionCommand as eo, turnCanonicalBatch as er, ToolCallSettled as et, CompactionCreated as f, LedgerCapabilities as fa, OpenDelegationCallEvidence as fi, JournalBoundary as fn, submissionSettlementRecordId as fo, IntegrityCheckName as fr, DurableAbortFailure as ft, DeploymentId as g, MarkReadyRequest as ga, RecoveryDecision as gi, RunJournal_d_exports as gn, ObligationEntry as gr, DurableApprovalResolver as gt, DefinitionDigests as h, MarkJoinedRequest as ha, PropagateChildAbort as hi, RunJournalUsage as hn, ObligationBlockedOn as hr, DurableApprovalFailure as ht, ApprovalDecision as i, ChildSettledOutcome as ia, CompleteChildAdmission as ii, ThreadStoreFailure as in, WaitingForChildSuspension as io, turnResponseBatchId as ir, WorkerAdmission as it, RecordEnvelope as j, ResolutionCompletedWithResult as ja, classifyRecovery as ji, runIdForSubmission as jn, AgentAttemptContext as jr, DurableWorkerRequirements as jt, ProducerEpoch as k, ReservedSettlement as ka, SettleAborted as ki, promptFromCanonicalRecords as kn, renderRecoveryExplanation as kr, DurableVerifyFailure as kt, CanonicalRecordEnvelope as l, InputAppliedMarker as la, FinalizeLedgerFromHistory as li, SettledSubmission as ln, submissionInputRecordId as lo, ExplainedSubmission as lr, WorkerReportPrepared as lt, DefinitionDigestInput as m, MarkInputAppliedRequest as ma, PendingApprovalEvidence as mi, RunJournalProjection as mn, IntegrityReport as mr, DurableAgentRuntime_d_exports as mt, AbortedSubmissionSettled as n, ChildReservationStatus as na, AwaitParentEstablishment as ni, ThreadStore as nn, UnknownResolutionIntent as no, turnPreparedBatchId as nr, ToolStepSettled as nt, CURRENT_CANONICAL_SCHEMA_VERSION as o, ClaimJoiningRequest as oa, DeclaredPendingBatchEvidence as oi, ThreadTail as on, submissionAbortBatchId as oo, turnResultsBatchId as or, WorkerInputRequested as ot, CompletedSubmissionSettled as p, LedgerError as pa, OpenToolCallEvidence as pi, RunJournalError as pn, IntegrityCheckStatus as pr, DurableAgentRuntime as pt, SubtreeBudgetReserved as q, SubmissionSnapshot as qa, ApprovalDecisionIntent as qi, toolCallResultBatchId as qn, digestJson as qr, ThreadCheckpoint as qt, AgentUpdateEmitted as r, ChildSettledNotification as ra, AwaitUnknownResolution as ri, ThreadStoreError as rn, WaitingChild as ro, turnResponseBatch as rr, UserInputRecorded as rt, CanonicalBatch as s, ClaimRequest as sa, DelegationAdmissionEvidence as si, ThreadTailRequest as sn, submissionAbortRecordId as so, Admin_d_exports as sr, WorkerOrigin as st, AbortRequested as t, ChildReservationId as ta, AwaitHostSettlement as ti, ThreadRecoveryCheckpoints as tn, UnknownResolutionConflict as to, turnIdForRun as tr, ToolCallUnknown as tt, CanonicalRecordPayload as u, JoinSnapshot as ua, MarkUnknown as ui, SubmissionStatus as un, submissionSettlementBatchId as uo, ExplainedUnknownCall as ur, WorkerReportRefused as ut, FailedSubmissionSettled as v, OwnershipLost as va, Recovery_d_exports as vi, approvalDecisionBatchId as vn, ObligationSeverity as vr, DurableExplainFailure as vt, ModelResponseInterrupted as w, RecoverySnapshotRequest as wa, ResumeFromTurnBoundary as wi, modelResponseInterruptedBatchId as wn, RetryRefusalReason as wr, DurableRuntimeConfig as wt, MAX_PERSISTED_JSON_DEPTH as x, OwnershipToken as xa, RepairJoinMarker as xi, compactionBatchId as xn, RecoveryDisposition as xr, DurableProgressFailure as xt, MAX_PERSISTED_JSON_BYTES as y, OwnershipRenewal as ya, ReleaseOrphanChildReservation as yi, childIdempotencyKeyFor as yn, ObligationThresholds as yr, DurableObligationFailure as yt, SettlementFailureDiagnostic as z, SettlementReservationSnapshot as za, AdmissionIndeterminate as zi, subagentRequestedRecordId as zn, compileRegistrations as zr, AppendResult as zt };
+//# sourceMappingURL=Records-BAGkekt8.d.mts.map