effect-agent 0.1.0-beta.13 → 0.1.0-beta.131

package/dist/Admin-C34cVKlT.d.mts

@@ -0,0 +1,3181 @@
+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 } 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 } from "./Usage-Dx0aknfk.mjs";
+import { a as ExhaustedLimit } from "./RunEvent-DIrzkjLr.mjs";
+import { t as ThreadHistory } from "./ThreadHistory-tS1KwxHR.mjs";
+import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-CaAkzGHL.mjs";
+import { a as AgentInputError } from "./AgentError-Bn1ytXRD.mjs";
+import { t as ToolParameterRejection } from "./ToolResult-BKdqWRff.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
+import { E as RunDispositionDeclaration, _ as InstructionSource, c as Definition, m as InputPromptSource, n as Any, r as AnyDefinition, t as Agent_d_exports, y as ModelServices } from "./Agent-D9cXqfF3.mjs";
+import { t as RunPolicyUsage } from "./RunPolicyUsage-ClZxyR46.mjs";
+import { c as WorkerError, f as WorkerRef, n as AssignmentTerminal } from "./Worker-fwWkBg12.mjs";
+import { G as RunToolAuthorization, O as RunCostEstimator, h as RunApprovalHook, x as RunContextPreparation } from "./RunOptions-CSBsSj0X.mjs";
+import { o as MessagingError, r as InputMessage } from "./Messaging-Dkg87ebg.mjs";
+import { t as MessagingHost } from "./MessagingHost-CqzpxbGz.mjs";
+import "./Messaging-JYYN3oYS.mjs";
+import { d as WorkerReportPreparationFailure, f as WorkerReporting, o as SubagentHost } from "./SubagentHost-DQjHFGqH.mjs";
+import { p as RuntimeBinding, r as AgentCompletionProjectionRequirements, s as AgentRuntimeRequirements } from "./AgentRuntime-DEDvMkAR.mjs";
+import { $ as ToolCallPrepared, A as ProducerId, I as RunCompleted, J as SubmissionSettledRecord, M as RecordId, O as PersistedJson, T as ModelResponseRecorded, V as SettlementFailureDiagnostic, a as BatchId, ct as WorkerAdmission, d as CanonicalSequence, dt as WorkerInputRequested, f as CompactionCreated, g as DeploymentId, h as DefinitionDigests, j as RecordEnvelope, l as CanonicalRecordEnvelope, m as DefinitionDigestInput, nt as ToolCallSettled, s as CanonicalBatch } from "./Records-B5GFWCpn.mjs";
+import { t as DigestError } from "./Digest-U69rDHuO.mjs";
+import { n as DurableRuntimeFailpoint, r as DurableRuntimeFailpointError } from "./DurableFailpoint-Cnr3wx1L.mjs";
+import { o as OperationDenied } from "./OperationAuthorizer-TzcQtpX5.mjs";
+import { s as ToolReconciler } from "./ToolReconciler-BmVRAHKs.mjs";
+import { t as WakeScheduler } from "./WakeScheduler-EjUF-GhC.mjs";
+import { Prompt, Tool } from "effect/unstable/ai";
+import { Cause, Context, Crypto, DateTime, Duration, Effect, Layer, Option, Result, Schema, Scope, Stream } from "effect";
+//#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 unique current executable is registered for the stable Agent identity. */
+declare class BindingUnavailable extends BindingUnavailable_base {}
+type DurableBindingFailure = BindingUnavailable;
+/** Exact immutable admission, lineage and delivery evidence; never an executable-code gate. */
+declare const definitionDigestsEqual: (left: DefinitionDigests, right: DefinitionDigests) => boolean;
+/** Change an operation version when its meaning, durable Steps or idempotency keys change. */
+interface ReplayVersions {
+  readonly tools: Readonly<Record<string, PersistedJson>>;
+}
+/** Compile current metadata without acquiring executable services. */
+declare const compileBindingContracts: (definition: Definition<Schema.Top, Schema.Top, unknown, import("effect/unstable/ai/Toolkit").Any, RunDispositionDeclaration<never, Schema.Top> | undefined, unknown, Schema.Top | undefined>, definitions: DefinitionDigestInput, versions?: ReplayVersions | undefined) => Effect.Effect<Pick<ResolvedBinding, "digests">, DigestError, Crypto.Crypto>;
+type ExecutableDefinition = AnyDefinition & {
+  readonly instructions: InstructionSource<never, unknown, unknown>;
+  readonly inputPrompt?: InputPromptSource<never, unknown, unknown> | undefined;
+};
+/** 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>;
+}
+/** 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>(agent: A, digests: DefinitionDigests) => Effect.Effect<ResolvedBinding, never, DurableWorkerRequirements<A>>;
+};
+/** 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;
+}) & {
+  /** Explicit operation versions let unchanged unfinished handlers survive toolbox changes. */
+  readonly continuity?: {
+    readonly versions: ReplayVersions;
+  };
+  /**
+   * 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.
+   * Provide DurableApprovalSuspension here when resources need retention before approval waits.
+   */
+  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> : 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, BindingUnavailable, DurableBindingFailure, DurableWorkerBinding, ExecutableAgentBinding, ReplayVersions, ResolvedBinding, compileBindingContracts, compileRegistrations, definitionDigestsEqual };
+}
+//#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 toolExecutionEvidence: ReadonlySet<string>;
+  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, agentUpdateRecordId, approvalDecisionBatchId, childIdempotencyKeyFor, childThreadIdFor, compactionBatchId, compactionRecordId, firstWorkerInputRecordId, markUnknownBatchId, modelResponseInterruptedBatchId, modelResponseInterruptedRecordId, modelResponseRecordId, peerMessageRecordId, projectRunJournal, projectRunJournalStream, promptFromCanonicalRecords, runCompletedRecordId, runCompletionDigest, runDurationBatchId, runDurationRecordId, runIdForSubmission, runStartedBatchId, runStartedRecordId, subagentJoinBatchId, subagentJoinedRecordId, subagentLineageBatchId, subagentLineageRecordId, subagentRequestedBatchId, subagentRequestedRecordId, subagentStartedBatchId, subagentStartedRecordId, toolApprovalDecisionRecordId, toolApprovalRequestRecordId, toolCallPreparedRecordId, toolCallResolutionBatchId, toolCallResolvedRecordId, toolCallResultBatchId, toolCallSettledRecordId, toolCallUnknownRecordId, toolStepSettledBatchId, toolStepSettledRecordId, turnApprovalsBatchId, turnBatchId, turnCanonicalBatch, turnIdForRun, turnPreparedBatchId, turnResponseBatch, turnResponseBatchId, turnResultsBatch, turnResultsBatchId, workerInputRecordId, workerOriginRecordId, workerReportRecordId };
+}
+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;
+declare const runDurationRecordId: (runId: RunId) => RecordId;
+declare const runDurationBatchId: (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;
+/** Native source reservation locator, including the first admission of a continuing worker. */
+declare const workerInputRecordId: (messageId: IdempotencyKey) => RecordId;
+/** Source-owned first reservation; native worker identity is minted from its first message. */
+declare const firstWorkerInputRecordId: (worker: WorkerRef) => RecordId;
+declare const workerOriginRecordId: (threadId: ThreadId) => RecordId;
+declare const workerReportRecordId: (messageId: IdempotencyKey) => RecordId;
+declare const peerMessageRecordId: (messageId: IdempotencyKey) => RecordId;
+/** Same immutable tuple used by native update admission; callers never parse its hash. */
+declare const agentUpdateRecordId: (threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">, runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">, updateId: string & import("effect/Brand").Brand<"@effect-agent/thread/IdempotencyKey">) => Effect.Effect<string & import("effect/Brand").Brand<"@effect-agent/thread/RecordId">, DigestError, Crypto.Crypto>;
+/** 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;
+  /** Prior-Run history with model-only unknown results closing incomplete application calls. */
+  readonly historyBefore: Prompt.Prompt;
+  /** Number of canonical Turns already committed for the projected Run. */
+  readonly committedTurns: number;
+  /** 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 `ModelResponseRecorded` Turn and the
+ * owning Run's resumable incomplete Tool Turn. It flushes each contiguous group of valid `ToolCallSettled` records into one Tool message,
+ * exactly mirroring the per-Turn commit shape produced by `turnCanonicalBatch` (no-tool Turns) and
+ * by the
+ * `turnResponseBatch`/`turnResultsBatch` split (tool-declaring Turns). The Phase 5 audit tags
+ * 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 until model-only unknown results close its missing calls. Those explanatory results
+ * are never canonical settlements or evidence for compaction, recovery or accounting. Real
+ * results replace them at the original declaration, including results appended after another Run.
+ * Prior user intent and assistant text remain visible; prior system instructions do not.
+ */
+/** @internal Lightweight canonical boundaries collected without retaining record payloads. */
+interface JournalBoundary {
+  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 toolOperations?: ModelResponseRecorded["toolOperations"] | undefined;
+  readonly toolParameterRejections?: ReadonlyArray<ToolParameterRejection> | undefined;
+  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;
+}
+/** Integrity of the original validated terminal values; never a current-code projection. */
+declare const runCompletionDigest: (completion: Pick<RunCompleted, "runId" | "output" | "runDisposition" | "finishReason" | "exhausted">) => Effect.Effect<string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">, DigestError, Crypto.Crypto>;
+/**
+ * Pure per-Turn canonical batch builder (TurnCompleted seam fold, D6/D8): one
+ * `ModelResponseRecorded` record plus one `ToolCallSettled` record per terminal Tool result, all
+ * 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, DigestError | RunJournalError, Crypto.Crypto>;
+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, SelectedThreadRead, ThreadCheckpoint, ThreadCheckpoints, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadOutstanding, ThreadOutstandingRequest, ThreadPeerCountRequest, ThreadRead, ThreadReadRequest, ThreadRecordRequest, ThreadRecoveryCheckpoints, ThreadRunInputRequest, ThreadSelection, ThreadStore, ThreadStoreDiagnostic, ThreadStoreError, ThreadStoreFailure, ThreadTail, ThreadTailRequest, ThreadWorkerStateRequest, getRecord, getRunInput, readOutstanding, readWorkerState };
+}
+declare const MAX_THREAD_EXPORT_RECORDS = 131072;
+/** Exact canonical identity; absence is not proof that an admission was never accepted. */
+declare const ThreadRecordRequest: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+}>;
+type ThreadRecordRequest = typeof ThreadRecordRequest.Type;
+/** The original user input for a Run, excluding later joined inputs. */
+declare const ThreadRunInputRequest: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+}>;
+type ThreadRunInputRequest = typeof ThreadRunInputRequest.Type;
+declare const ThreadOutstandingRequest: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  /** Exceeding this bound fails; a truncated inventory never grants authority. */
+  readonly limit: Schema.Int;
+}>;
+type ThreadOutstandingRequest = typeof ThreadOutstandingRequest.Type;
+interface ThreadOutstanding {
+  readonly threadId: ThreadId;
+  readonly throughSequence: CanonicalSequence;
+  readonly complete: true;
+  readonly operations: ReadonlyArray<{
+    readonly submissionId: SubmissionId;
+    readonly prepared: ToolCallPrepared;
+    /** Prepared is not an unknown outcome or a grant to execute. */
+    readonly state: "prepared" | "unknown";
+  }>;
+  /** Source reservations without proof that external effects are resolved. */
+  readonly workerInputs: ReadonlyArray<WorkerInputRequested>;
+}
+/** Native worker reservation/accounting snapshot at a captured canonical tail. */
+declare const ThreadWorkerStateRequest: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly limit: Schema.Int;
+}>;
+type ThreadWorkerStateRequest = typeof ThreadWorkerStateRequest.Type;
+/** Saturating lifetime peer-message count: the result is at most the requested cap. */
+declare const ThreadPeerCountRequest: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly limit: Schema.Int;
+}>;
+type ThreadPeerCountRequest = typeof ThreadPeerCountRequest.Type;
+/** Host-owned read: authenticate the Thread and exact locator before calling. */
+declare const getRecord: (request: {
+  readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  readonly recordId: string & import("effect/Brand").Brand<"@effect-agent/thread/RecordId">;
+}) => Effect.Effect<Option.Option<CanonicalRecordEnvelope>, ThreadNotMaterialized | ThreadStoreError, ThreadStore>;
+declare const getRunInput: (request: {
+  readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  readonly runId: string & import("effect/Brand").Brand<"@effect-agent/core/RunId">;
+}) => Effect.Effect<Option.Option<CanonicalRecordEnvelope>, ThreadNotMaterialized | ThreadStoreError, ThreadStore>;
+/** A bounded snapshot of native lifetime and source-submission worker accounting. */
+declare const readWorkerState: (request: {
+  readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  readonly sourceSubmissionId?: (string & import("effect/Brand").Brand<"@effect-agent/core/SubmissionId">) | undefined;
+  readonly limit: number;
+}) => Effect.Effect<{
+  threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  tailSequence: number & import("effect/Brand").Brand<"@effect-agent/thread/CanonicalSequence">;
+  tailDigest: string & import("effect/Brand").Brand<"@effect-agent/thread/Digest">;
+  records: CanonicalRecordEnvelope[];
+}, ThreadNotMaterialized | ThreadStoreError, ThreadStore>;
+/**
+ * Work is proportional to outstanding records, independent of completed history. Unknown
+ * effects survive abort and resolution intent; only canonical closure removes them. A
+ * preparation from another Run still requires native recovery before it can be treated as
+ * safe. This snapshot grants no execution authority and does not freeze other owners.
+ */
+declare const readOutstanding: (request: {
+  readonly threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  readonly limit: number;
+}) => Effect.Effect<{
+  threadId: string & import("effect/Brand").Brand<"@effect-agent/core/ThreadId">;
+  throughSequence: number & import("effect/Brand").Brand<"@effect-agent/thread/CanonicalSequence">;
+  complete: true;
+  operations: {
+    readonly submissionId: SubmissionId;
+    readonly prepared: ToolCallPrepared;
+    /** Prepared is not an unknown outcome or a grant to execute. */
+    readonly state: "prepared" | "unknown";
+  }[];
+  workerInputs: WorkerInputRequested[];
+}, LedgerError | ThreadNotMaterialized | ThreadStoreError, SubmissionLedger | ThreadStore>;
+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 {}
+/** Closed native selections; mutable metadata is read at this exact canonical tail. */
+declare const ThreadSelection: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"RecordId">;
+  readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"RunInput">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Outstanding">;
+  readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerExecution">;
+  readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerState">;
+  readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+}>]>;
+type ThreadSelection = typeof ThreadSelection.Type;
+/** Nested page makes an old ThreadRead decoder reject, never strip a selection into history. */
+declare const SelectedThreadRead: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly selection: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"RecordId">;
+    readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"RunInput">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Outstanding">;
+    readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+    readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerExecution">;
+    readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+    readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerState">;
+    readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+    readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+    readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  }>]>;
+  readonly page: Schema.Struct<{
+    readonly afterSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+    readonly limit: Schema.Natural;
+  }>;
+}>;
+type SelectedThreadRead = typeof SelectedThreadRead.Type;
+declare const ThreadReadRequest: Schema.Union<readonly [Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly selection: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"RecordId">;
+    readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"RunInput">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Outstanding">;
+    readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+    readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerExecution">;
+    readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+    readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerState">;
+    readonly expectedTailSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+    readonly expectedTailDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+    readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  }>]>;
+  readonly page: Schema.Struct<{
+    readonly afterSequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+    readonly limit: Schema.Natural;
+  }>;
+}>, typeof ThreadRead]>;
+type ThreadReadRequest = typeof ThreadReadRequest.Type;
+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 {}
+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>;
+}>, {}>;
+/** Maximum canonical records represented by one Thread export. */
+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 ThreadStoreDiagnostic_base: Schema.Class<ThreadStoreDiagnostic, Schema.Struct<{
+  readonly causeTag: Schema.String;
+  readonly operation: Schema.String;
+  readonly decoder: Schema.optionalKey<Schema.String>;
+  readonly issueTag: Schema.optionalKey<Schema.String>;
+  readonly sequence: Schema.optionalKey<Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">>;
+}>, {}>;
+/**
+ * Content-free storage provenance constructed by adapters from source-authored labels.
+ * Raw foreign lookalikes are not trusted diagnostics. Never include rejected values, SQL,
+ * or schema messages.
+ */
+declare class ThreadStoreDiagnostic extends ThreadStoreDiagnostic_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>;
+  readonly diagnostic: Schema.optionalKey<typeof ThreadStoreDiagnostic>;
+}>, 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: ThreadReadRequest) => 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;
+  /** Indexed scalar count; unsupported adapters fail closed at the caller. */
+  readonly countPeerMessages?: ((request: ThreadPeerCountRequest) => Effect.Effect<number, ThreadStoreError | ThreadNotMaterialized>) | undefined;
+}>;
+declare class ThreadStore extends ThreadStore_base {}
+declare namespace DurableAgentRuntime_d_exports {
+  export { ApprovalSuspensionError, DurableAbortFailure, DurableAgentRuntime, DurableApprovalFailure, DurableApprovalResolver, DurableApprovalSuspension, DurableAwaitFailure, DurableExplainFailure, DurableObligationFailure, DurableObserveOptions, DurableProgressFailure, DurableResolveFailure, DurableRetryFailure, DurableRuntimeConfig, DurableRuntimeConfigOptions, DurableSubmitAgent, DurableSubmitFailure, DurableSubmitOptions, DurableVerifyFailure, DurableWorkerFailure, DurableWorkerRequirements, Receipt, RecoveryBlocked, RecoveryFailure, RecoveryReport, RecoverySweepOptions, RecoverySweepResult, childReservationIdFor, isolateRecovery, 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 RecoveryFailure_base: Schema.Class<RecoveryFailure, Schema.Struct<{
+  readonly phase: Schema.Literals<readonly ["history", "recovery"]>;
+  readonly reason: Schema.Literals<readonly ["failure", "defect", "timeout"]>;
+  readonly errorTag: Schema.String;
+  /** Static operation names only; error messages and payloads are deliberately excluded. */
+  readonly operation: Schema.String;
+  /** Ordered, bounded classifications. Foreign labels, operations and prose stay private. */
+  readonly causes: Schema.$Array<Schema.Struct<{
+    readonly errorTag: Schema.Literals<readonly ["AdmissionPolicyError", "DigestError", "LedgerError", "OwnershipLost", "SettlementConflict", "ThreadStoreError", "ThreadNotMaterialized", "AppendConflict", "FenceRejected", "RunJournalError", "DurableRuntimeFailpointError", "SchemaError", "Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError", "URIError", "EvalError", "AggregateError", "ForeignError", "NonErrorCause"]>;
+  }>>;
+  readonly causesTruncated: Schema.optionalKey<Schema.Literal<true>>;
+  readonly diagnostic: Schema.optionalKey<typeof ThreadStoreDiagnostic>;
+}>, {}>;
+/** Recovery could not establish execution authority. This is never a Settlement or replay grant. */
+declare class RecoveryFailure extends RecoveryFailure_base {}
+/** @internal One bounded failure boundary for execution history and host recovery control reads. */
+declare const isolateRecovery: <A, E extends DurableWorkerFailure, R>(body: Effect.Effect<A, E, R>, options: {
+  readonly timeout: Duration.Duration;
+  readonly phase: () => RecoveryFailure["phase"];
+  readonly operation?: string;
+}) => Effect.Effect<Result.Result<A, RecoveryFailure>, E, Exclude<R, Scope.Scope>>;
+declare const RecoveryBlocked_base: Schema.Class<RecoveryBlocked, Schema.TaggedStruct<"RecoveryBlocked", {
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly failure: typeof RecoveryFailure;
+}>, Cause.YieldableError>;
+/** One failed Thread remains pending; the host must not claim it before recovery succeeds. */
+declare class RecoveryBlocked extends RecoveryBlocked_base {}
+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` = this Submission is parked on an Unknown Outcome awaiting the authorized
+   * DUR-017 resolution path — the settlement obligation stays visible while no worker permit
+   * is consumed (durability §16).
+   */
+  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 {}
+declare const RecoverySweepResult_base: Schema.Class<RecoverySweepResult, Schema.Struct<{
+  readonly reports: Schema.$Array<typeof RecoveryReport>;
+  /** Exactly one fault per failed Thread, regardless of its queued Submission count. */
+  readonly blocked: Schema.$Array<typeof RecoveryBlocked>;
+}>, {}>;
+/** Submission decisions and operational faults have different ownership and settlement semantics. */
+declare class RecoverySweepResult extends RecoverySweepResult_base {}
+/** Select one Thread before reading history, or omit to recover every pending Thread. */
+interface RecoverySweepOptions {
+  readonly threadId?: ThreadId;
+}
+/** 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;
+declare const ApprovalSuspensionError_base: Schema.Class<ApprovalSuspensionError, Schema.TaggedStruct<"ApprovalSuspensionError", {
+  readonly cause: Schema.Defect;
+}>, Cause.YieldableError>;
+/** Attempt resources could not be retained before deliberate approval suspension. */
+declare class ApprovalSuspensionError extends ApprovalSuspensionError_base {}
+type DurableWorkerFailure = AdmissionPolicyError | ApprovalSuspensionError | 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>;
+/**
+ * Optional attempt-local retention before an unresolved approval releases ownership. Supply
+ * this from the Attempt's Layer, capturing its live resources. The canonical approval request
+ * already exists; claim renewal and abort observation remain active while this operation runs.
+ * Return only after retention is confirmed. Failure leaves the accepted work owed and preserves
+ * its cause; interruption keeps normal resource cleanup. No approval-gated Tool runs here.
+ *
+ * A decision racing with successful retention resumes the pending batch in a fresh Attempt,
+ * after the old services and claim finalize. The default leaves existing suspension unchanged.
+ */
+declare const DurableApprovalSuspension: Context.Reference<Effect.Effect<void, ApprovalSuspensionError> | 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 {
+  /**
+   * Deployment identity and the conservative operation version for direct execution without
+   * a registered binding. Reuse asserts unchanged handler, Step, and idempotency semantics.
+   */
+  readonly deploymentId: DeploymentId;
+  readonly producerId: ProducerId;
+  /** `awaitSettlement` ledger re-check cadence when no wake arrives (default 500ms). */
+  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;
+  /** Cooperative bound for one Thread's recovery, including child reads (default 30s). */
+  readonly recoveryTimeout?: 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 recoveryTimeout: 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; owned repair attempts
+   * append a best-effort `RepairAnnotated` with their actual claim epoch (DUR-013). Typed `RetryRefused`
+   * for settled work and for lanes owned by the resolveUnknown/resolveApproval paths.
+   */
+  readonly retry: (command: RetryCommand) => Effect.Effect<RecoveryReport, DurableRetryFailure>;
+  /** 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 the FIFO head, closing its Attempt 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>;
+  /**
+   * Recover each pending Thread independently. History/child failures, defects and the
+   * configured timeout return one RecoveryBlocked per Thread; hosts must retain visibility
+   * outside execution history and exclude those Threads from claims. Ledger scan failures,
+   * owner interruption and injected crash boundaries still fail the whole sweep.
+   * Optional Thread selection lets a host recover its selected dispatch lane independently
+   * of old cleanup. Unselected Threads are neither read nor reported by this call.
+   */
+  readonly runRecovery: (options?: RecoverySweepOptions) => Effect.Effect<RecoverySweepResult, 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),
+ *   over a singleton current Binding: a claimed head belonging to a different Agent never
+ *   runs against this binding. Missing bindings leave accepted roots and children owed.
+ * - `processThreadResolved(threadId)` / `runResolvedWorker` — the
+ *   equivalents over registrations owned by the runtime Layer: each stable `agentId` selects
+ *   one current Binding. Unfinished operation contracts gate handler execution independently
+ *   of immutable admission evidence; missing bindings release the claim with a typed refusal.
+ * - `runRecovery()` — classify every nonterminal Submission with the pure `classifyRecovery` and
+ *   execute repair decisions, annotating owned repair attempts with their granted epochs
+ *   (DUR-013). Untouched ready input and model-resuming work are reported `deferred` for a
+ *   worker claim; Submissions parked on
+ *   Unknown Outcomes are reported `unknown`. The S2 binding-free Subagent executors (admission
+ *   completion, start-link repair, waiting restoration, wake replay, canonical join accounting,
+ *   abort propagation, orphan reservation release) run here; the settlement join itself is
+ *   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 : 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 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, SubmissionWorkItem, SuspendRequest, SuspensionOutcome, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WaitingChild, WaitingForChildSuspension, WorkerLedgerState, WorkerStopCommand, settlementFailureFromRecord, submissionAbortBatchId, submissionAbortRecordId, submissionInputBatchId, submissionInputRecordId, submissionSettlementBatchId, submissionSettlementId, submissionSettlementRecordId, workerTerminalFromRecord };
+}
+/**
+ * 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 Tool Call has a durable Unknown Outcome; this Submission is
+ *   parked until an authorized resolution covers every open call or a durable abort intent
+ *   authorizes cleanup without Tool replay. Later eligible input may run (DUR-012/DUR-017).
+ *
+ * `claim` never grants or bypasses a `joining`, `joined`, or `suspended` head. It skips unknown
+ * work without an abort intent. Any live ownership in the Thread prevents another claim.
+ */
+declare const SubmissionState: Schema.Literals<readonly ["admitted", "ready", "joining", "joined", "running", "input-applied", "suspended", "unknown", "terminalizing", "settled"]>;
+type SubmissionState = typeof SubmissionState.Type;
+/**
+ * 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;
+  readonly cause: Schema.optionalKey<Schema.decodeTo<Schema.Unknown, Schema.Codec<Diagnostic, Diagnostic, never, never>, never, never>>;
+  readonly stack: Schema.optionalKey<Schema.String>;
+}>, 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 continuationOf: Schema.optionalKey<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 receipt: typeof Receipt;
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      }>>;
+      readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+      readonly lifecycle: Schema.optionalKey<Schema.Literal<"assignment">>;
+      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 returnAddress: Schema.optionalKey<Schema.Struct<{
+          readonly input: Schema.declare<Schema.Json, Schema.Json>;
+          readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+          readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+          readonly depth: Schema.Natural;
+          readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+          readonly workerAdmission: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+        }>>;
+      }>>;
+    }>;
+    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 SubmissionWorkItem_base: Schema.Class<SubmissionWorkItem, 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 deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+  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"]>;
+}>, {}>;
+/**
+ * Control-only worklist entry. Discovery validates identities, ordering and state without
+ * decoding retained execution payloads. Hydrate only the selected Thread through `lookup`
+ * or `loadRecoverySnapshot`, inside its recovery failure boundary.
+ */
+declare class SubmissionWorkItem extends SubmissionWorkItem_base {}
+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 deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+  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 agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly agentDigests: typeof DefinitionDigests;
+  readonly inputPayload: Schema.declare<Schema.Json, Schema.Json>;
+  readonly inputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly settledOutcome: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "aborted"]>>;
+  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 continuationOf: Schema.optionalKey<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 receipt: typeof Receipt;
+        readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      }>>;
+      readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+      readonly lifecycle: Schema.optionalKey<Schema.Literal<"assignment">>;
+      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 returnAddress: Schema.optionalKey<Schema.Struct<{
+          readonly input: Schema.declare<Schema.Json, Schema.Json>;
+          readonly principal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+          readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+          readonly depth: Schema.Natural;
+          readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+          readonly workerAdmission: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+        }>>;
+      }>>;
+    }>;
+    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 {}
+/** Bounded native control facts. Canonical input/Run records remain ThreadStore-owned. */
+declare const WorkerLedgerState: Schema.Struct<{
+  readonly latest: Schema.NullOr<typeof SubmissionSnapshot>;
+  readonly active: Schema.NullOr<typeof SubmissionSnapshot>;
+  readonly stopped: Schema.Boolean;
+  readonly terminal: Schema.optionalKey<Schema.Literals<readonly ["completed", "failed", "cancelled"]>>;
+}>;
+type WorkerLedgerState = typeof WorkerLedgerState.Type;
+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.declareConstructor<{
+    readonly errorTag: string;
+    readonly message: string;
+    readonly diagnostic?: Diagnostic | undefined;
+    readonly context?: {
+      readonly agentId?: string | undefined;
+      readonly threadId?: string | undefined;
+      readonly runId?: string | undefined;
+      readonly submissionId?: string | undefined;
+      readonly attemptId?: string | undefined;
+      readonly turnId?: string | undefined;
+      readonly toolCallId?: string | undefined;
+      readonly toolName?: string | undefined;
+      readonly callId?: string | undefined;
+      readonly check?: string | undefined;
+      readonly operation?: string | undefined;
+    } | undefined;
+  }, {
+    readonly errorTag: string;
+    readonly message: string;
+    readonly diagnostic?: Diagnostic | undefined;
+    readonly context?: {
+      readonly agentId?: string | undefined;
+      readonly threadId?: string | undefined;
+      readonly runId?: string | undefined;
+      readonly submissionId?: string | undefined;
+      readonly attemptId?: string | undefined;
+      readonly turnId?: string | undefined;
+      readonly toolCallId?: string | undefined;
+      readonly toolName?: string | undefined;
+      readonly callId?: string | undefined;
+      readonly check?: string | undefined;
+      readonly operation?: string | undefined;
+    } | undefined;
+  }, readonly [Schema.Struct<{
+    readonly errorTag: Schema.NonEmptyString;
+    readonly message: Schema.String;
+    readonly diagnostic: Schema.optionalKey<Schema.Codec<Diagnostic, Diagnostic, never, never>>;
+    readonly context: Schema.optionalKey<Schema.declareConstructor<{
+      readonly agentId?: string | undefined;
+      readonly threadId?: string | undefined;
+      readonly runId?: string | undefined;
+      readonly submissionId?: string | undefined;
+      readonly attemptId?: string | undefined;
+      readonly turnId?: string | undefined;
+      readonly toolCallId?: string | undefined;
+      readonly toolName?: string | undefined;
+      readonly callId?: string | undefined;
+      readonly check?: string | undefined;
+      readonly operation?: string | undefined;
+    }, {
+      readonly agentId?: string | undefined;
+      readonly threadId?: string | undefined;
+      readonly runId?: string | undefined;
+      readonly submissionId?: string | undefined;
+      readonly attemptId?: string | undefined;
+      readonly turnId?: string | undefined;
+      readonly toolCallId?: string | undefined;
+      readonly toolName?: string | undefined;
+      readonly callId?: string | undefined;
+      readonly check?: string | undefined;
+      readonly operation?: string | undefined;
+    }, readonly [Schema.Struct<{
+      readonly agentId: Schema.optionalKey<Schema.String>;
+      readonly threadId: Schema.optionalKey<Schema.String>;
+      readonly runId: Schema.optionalKey<Schema.String>;
+      readonly submissionId: Schema.optionalKey<Schema.String>;
+      readonly attemptId: Schema.optionalKey<Schema.String>;
+      readonly turnId: Schema.optionalKey<Schema.String>;
+      readonly toolCallId: Schema.optionalKey<Schema.String>;
+      readonly toolName: Schema.optionalKey<Schema.String>;
+      readonly callId: Schema.optionalKey<Schema.String>;
+      readonly check: Schema.optionalKey<Schema.String>;
+      readonly operation: Schema.optionalKey<Schema.String>;
+    }>], {
+      readonly agentId?: string | undefined;
+      readonly threadId?: string | undefined;
+      readonly runId?: string | undefined;
+      readonly submissionId?: string | undefined;
+      readonly attemptId?: string | undefined;
+      readonly turnId?: string | undefined;
+      readonly toolCallId?: string | undefined;
+      readonly toolName?: string | undefined;
+      readonly callId?: string | undefined;
+      readonly check?: string | undefined;
+      readonly operation?: string | undefined;
+    }>>;
+  }>], {
+    readonly errorTag: string;
+    readonly message: string;
+    readonly diagnostic?: Diagnostic | undefined;
+    readonly context?: {
+      readonly agentId?: string | undefined;
+      readonly threadId?: string | undefined;
+      readonly runId?: string | undefined;
+      readonly submissionId?: string | undefined;
+      readonly attemptId?: string | undefined;
+      readonly turnId?: string | undefined;
+      readonly toolCallId?: string | undefined;
+      readonly toolName?: string | undefined;
+      readonly callId?: string | undefined;
+      readonly check?: string | undefined;
+      readonly operation?: string | undefined;
+    } | undefined;
+  }>>;
+  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;
+/**
+ * Assignment intent derived only from frozen admission and exact settlement evidence.
+ * Joined receipts and cancellation before a Run starts do not finish an assignment.
+ * Adapters suppress completed intent when newer accepted input remains unapplied, then
+ * install the first seal and outstanding abort intents atomically before releasing the lane.
+ */
+declare const workerTerminalFromRecord: (submission: SubmissionSnapshot, record: RecordEnvelope) => AssignmentTerminal | undefined;
+/** Destination-owned permanent inbox seal; recorded atomically with all outstanding abort intents. */
+declare const WorkerStopCommand: Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly author: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+}>;
+type WorkerStopCommand = typeof WorkerStopCommand.Type;
+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`, parking that Submission without changing ownership or the Thread epoch. Idempotent.
+ */
+declare class MarkUnknownRequest extends MarkUnknownRequest_base {}
+declare const ResolutionCompletedWithResult_base: Schema.Class<ResolutionCompletedWithResult, Schema.TaggedStruct<"CompletedWithResult", {
+  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.decodeTo<Schema.Unknown, Schema.Codec<Diagnostic, Diagnostic, never, never>, never, never>>;
+}>, 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>;
+  /** Optional for third-party adapters. Remaining ownership must reach zero before stop acknowledgement. */
+  readonly inspectWorker?: (threadId: ThreadId) => Effect.Effect<WorkerLedgerState, LedgerError>;
+  readonly stopWorker?: (request: WorkerStopCommand) => Effect.Effect<number, 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<SubmissionWorkItem, 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` — claims the lowest unsettled `queueSequence` after skipping only unknown rows
+ *   without abort intent. Approval, joining and child-wait barriers remain ordered. Returns
+ *   `Option.none` when no eligible work exists or ANY lease in the Thread is live, including
+ *   a lease belonging to the same producer. A successful claim atomically bumps the Thread's producer
+ *   epoch — fencing every stale Attempt out of canonical appends (DUR-006) — mints a fresh
+ *   `attemptId` and `ownershipToken`, and starts the ownership lease (D5: adapters default to
+ *   `DEFAULT_OWNERSHIP_LEASE_DURATION`, configurable). An expired lease makes the head
+ *   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. Native adapters seal opted-in worker assignments atomically before
+ *   releasing the lane. Otherwise 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`, parking the Submission while its accepted settlement obligation stays visible.
+ *   Existing ownership must release or expire before another claim (DUR-009/DUR-017).
+ *   Fails with `SettlementConflict` once settled.
+ * - `recordUnknownResolution` — durable, idempotent per `(submissionId, toolCallId)`; a
+ *   divergent re-resolution fails with `UnknownResolutionConflict`. Transitions
+ *   `unknown → input-applied` once no open call remains, waking the lane. Fails with
+ *   `SettlementConflict` once settled.
+ * - `scanNonterminal` — streams control-only entries for every Submission whose state is not
+ *   `settled`, ordered by (threadId, queueSequence); recovery's admission-independent worklist
+ *   (DUR-014). It must not decode execution payloads. SQL or control-identity corruption fails
+ *   the scan; selected-Thread payload hydration belongs inside the caller's isolation boundary.
+ * - `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 durability §15 batch-resume window. Mutation preparation has not committed; readonly
+ * handlers may already have run. The worker checks each unfinished operation before execution.
+ */
+declare class DeclaredPendingBatchEvidence extends DeclaredPendingBatchEvidence_base {}
+declare const PendingApprovalEvidence_base: Schema.Class<PendingApprovalEvidence, Schema.Struct<{
+  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
+ * checks unfinished contracts and resumes the declared batch without model re-invocation. S2 also
+ * routes an open delegation call WITHOUT establishment evidence here (spec §13 row 1): the
+ * declared batch re-executes and the idempotent establishment converges on one child. */
+declare class ResumePendingToolBatch extends ResumePendingToolBatch_base {}
+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: this Submission stays parked awaiting the authorized
+ * DUR-017 resolution path; the obligation stays visible, nothing replays. */
+declare class AwaitUnknownResolution extends AwaitUnknownResolution_base {}
+declare const ApplyUnknownResolutions_base: Schema.Class<ApplyUnknownResolutions, Schema.TaggedStruct<"ApplyUnknownResolutions", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** Durable resolution intents cover every open call: wake the original Submission when its
+ * required retry contract is supported. Canonical outcomes are applied by the next claim. */
+declare class ApplyUnknownResolutions extends ApplyUnknownResolutions_base {}
+declare const RevertJoining_base: Schema.Class<RevertJoining, Schema.TaggedStruct<"RevertJoining", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+}>, {}>;
+/** `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 — the worker checks original
+ *     operation contracts; missing preparation proves no mutation dispatch, not readonly nonexecution (§15).
+ * 11. `admitted` → a parent-linked Submission whose Thread lacks the canonical lineage
+ *     record defers (AwaitParentEstablishment: the parent's idempotent establishment
+ *     completes it); otherwise
+ *     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 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 real canonical ToolCallSettled closes this call; an intent alone is not an outcome. */
+  readonly resolved: Schema.Boolean;
+}>, {}>;
+/** One durable Unknown Outcome and whether its result is canonical (DUR-017). */
+declare class ExplainedUnknownCall extends ExplainedUnknownCall_base {}
+declare const ExplainedEvidence_base: Schema.Class<ExplainedEvidence, Schema.Struct<{
+  readonly threadMaterialized: Schema.Boolean;
+  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>;
+  /** Original prepared operation identities, arguments and recovery contracts; settled calls are excluded. */
+  readonly pendingOperations: Schema.withConstructorDefault<Schema.$Array<typeof ToolCallPrepared>>;
+  /** Delegation Tool Calls with an open parent-side obligation. */
+  readonly openDelegationCalls: Schema.$Array<typeof OpenDelegationCallEvidence>;
+  /** Canonically requested approvals without a canonical decision. */
+  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
+ * operator and decision are logged. A repair with a claim also appends a best-effort
+ * `RepairAnnotated` attempt using that claim's epoch; state-only repairs do not append audits.
+ */
+declare class RetryCommand extends RetryCommand_base {}
+/** Why a retry was refused without executing anything. */
+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): Submissions waiting on `AwaitUnknownResolution` or
+ * `AwaitApprovalDecision` have their own authorized operations, and settled work is never
+ * re-driven. The refusal names the classifier decision so the operator sees WHY.
+ */
+declare class RetryRefused extends RetryRefused_base {}
+//#endregion
+export { RepairSubagentStartLink as $, toolCallResolutionBatchId as $i, DurableApprovalSuspension as $n, ThreadStoreDiagnostic as $r, RecoverySnapshot as $t, AwaitChildSettlement as A, modelResponseRecordId as Ai, UnknownResolution as An, FencedAppendRequest as Ar, ChildReservationConflict as At, MarkUnknown as B, runStartedBatchId as Bi, submissionAbortRecordId as Bn, ThreadMaterialization as Br, JoinSnapshot as Bt, renderRecoveryExplanation as C, DurableWorkerBinding as Ca, childThreadIdFor as Ci, SubmissionSnapshot as Cn, recoveryRepairRecordId as Cr, ApprovalDecisionIntent as Ct, ApplyUnknownResolutions as D, compileBindingContracts as Da, markUnknownBatchId as Di, SuspensionOutcome as Dn, AppendResult as Dr, ChildAttachmentSnapshot as Dt, ApplyJoinAccounting as E, ResolvedBinding as Ea, firstWorkerInputRecordId as Ei, SuspendRequest as En, AppendConflict as Er, BeginChildBudgetReleaseRequest as Et, CompleteMaterialization as F, runCompletedRecordId as Fi, WaitingForChildSuspension as Fn, SelectedThreadRead as Fr, Claim as Ft, PropagateChildAbort as G, subagentLineageRecordId as Gi, submissionSettlementRecordId as Gn, ThreadPeerCountRequest as Gr, MarkJoinedRequest as Gt, OpenDelegationCallEvidence as H, subagentJoinBatchId as Hi, submissionInputRecordId as Hn, ThreadObservation as Hr, LedgerCapabilities as Ht, DeclaredPendingBatchEvidence as I, runCompletionDigest as Ii, WorkerLedgerState as In, ThreadCheckpoint as Ir, ClaimJoiningRequest as It, Recovery_d_exports as J, subagentStartedBatchId as Ji, DurableAbortFailure as Jn, ThreadRecordRequest as Jr, OwnershipLost as Jt, RecoveryDecision as K, subagentRequestedBatchId as Ki, workerTerminalFromRecord as Kn, ThreadRead as Kr, MarkReadyRequest as Kt, DelegationAdmissionEvidence as L, runDurationBatchId as Li, WorkerStopCommand as Ln, ThreadCheckpoints as Lr, ClaimRequest as Lt, AwaitParentEstablishment as M, projectRunJournal as Mi, UnknownResolutionConflict as Mn, MAX_THREAD_EXPORT_RECORDS as Mr, ChildReservationStatus as Mt, AwaitUnknownResolution as N, projectRunJournalStream as Ni, UnknownResolutionIntent as Nn, SaveCheckpointRequest as Nr, ChildSettledNotification as Nt, AwaitApprovalDecision as O, compileRegistrations as Oa, modelResponseInterruptedBatchId as Oi, SuspensionReason as On, CheckpointRejected as Or, ChildBudgetReservationRequest as Ot, CompleteChildAdmission as P, promptFromCanonicalRecords as Pi, WaitingChild as Pn, SaveRecoveryCheckpointRequest as Pr, ChildSettledOutcome as Pt, RepairReadiness as Q, toolCallPreparedRecordId as Qi, DurableApprovalResolver as Qn, ThreadStore as Qr, ParentLinkage as Qt, EnsureWaitingForChild as R, runDurationRecordId as Ri, settlementFailureFromRecord as Rn, ThreadExport as Rr, DEFAULT_OWNERSHIP_LEASE_DURATION as Rt, recoveryDecisionMeaning as S, DurableBindingFailure as Sa, childIdempotencyKeyFor as Si, SubmissionLookupByKey as Sn, recoveryRepairBatchId as Sr, ApprovalDecisionCommand as St, ApplyInput as T, ReplayVersions as Ta, compactionRecordId as Ti, SubmissionWorkItem as Tn, threadCreatedRecordId as Tr, AttachChildToReservationRequest as Tt, OpenToolCallEvidence as U, subagentJoinedRecordId as Ui, submissionSettlementBatchId as Un, ThreadOutstanding as Ur, LedgerError as Ut, NoAction as V, runStartedRecordId as Vi, submissionInputBatchId as Vn, ThreadNotMaterialized as Vr, JoiningClaim as Vt, PendingApprovalEvidence as W, subagentLineageBatchId as Wi, submissionSettlementId as Wn, ThreadOutstandingRequest as Wr, MarkInputAppliedRequest as Wt, RepairInputMarker as X, toolApprovalDecisionRecordId as Xi, DurableAgentRuntime_d_exports as Xn, ThreadRunInputRequest as Xr, OwnershipSnapshot as Xt, ReleaseOrphanChildReservation as Y, subagentStartedRecordId as Yi, DurableAgentRuntime as Yn, ThreadRecoveryCheckpoints as Yr, OwnershipRenewal as Yt, RepairJoinMarker as Z, toolApprovalRequestRecordId as Zi, DurableApprovalFailure as Zn, ThreadSelection as Zr, OwnershipToken as Zt, RetryCommand as _, workerReportRecordId as _a, RunJournalUsage as _i, SubmissionLedger as _n, RecoveryReport as _r, AdmissionPolicyError as _t, IntegrityCheck as a, toolStepSettledRecordId as aa, ThreadWorkerStateRequest as ai, ReservedSettlement as an, DurableResolveFailure as ar, SettleAborted as at, obligationSeverityOf as b, AgentRegistration as ba, agentUpdateRecordId as bi, SubmissionLookup as bn, childReservationIdFor as br, AdmissionResult as bt, IntegrityReport as c, turnCanonicalBatch as ca, readOutstanding as ci, ResolutionNeverHappened as cn, DurableRuntimeConfigOptions as cr, AbortCommand as ct, ObligationReport as d, turnResponseBatch as da, SettledSubmission as di, Settlement as dn, DurableSubmitOptions as dr, AdmissionAdmitted as dt, toolCallResolvedRecordId as ea, ThreadStoreError as ei, RecoverySnapshotRequest as en, DurableAwaitFailure as er, ResumeFromTurnBoundary as et, ObligationSeverity as f, turnResponseBatchId as fa, SubmissionStatus as fi, SettlementConflict as fn, DurableVerifyFailure as fr, AdmissionConflict as ft, RecoveryExplanation as g, workerOriginRecordId as ga, RunJournalProjection as gi, SubmissionAdmissionFence as gn, RecoveryFailure as gr, AdmissionNotAdmitted as gt, RecoveryDisposition as h, workerInputRecordId as ha, RunJournalError as hi, SettlementReservationSnapshot as hn, RecoveryBlocked as hr, AdmissionIndeterminate as ht, ExplainedUnknownCall as i, toolStepSettledBatchId as ia, ThreadTailRequest as ii, ReservedChildBudget as in, DurableProgressFailure as ir, RevertJoining as it, AwaitHostSettlement as j, peerMessageRecordId as ji, UnknownResolutionCommand as jn, LoadCheckpointRequest as jr, ChildReservationId as jt, AwaitChildAdmissionResolution as k, definitionDigestsEqual as ka, modelResponseInterruptedRecordId as ki, SuspensionSnapshot as kn, FenceRejected as kr, ChildBudgetReservationSnapshot as kt, ObligationBlockedOn as l, turnIdForRun as la, readWorkerState as li, ResolutionSafeToRetry as ln, DurableSubmitAgent as lr, AbortIntent as lt, RECOVERY_DECISION_MEANINGS as m, turnResultsBatchId as ma, JournalBoundary as mi, SettlementReservation as mn, DurableWorkerRequirements as mr, AdmissionGroup as mt, ExplainedEvidence as n, toolCallSettledRecordId as na, ThreadStore_d_exports as ni, ReleaseOwnershipRequest as nn, DurableObligationFailure as nr, ResumeSuspended as nt, IntegrityCheckName as o, turnApprovalsBatchId as oa, getRecord as oi, ResolutionAbortSubmission as on, DurableRetryFailure as or, SettleJoinedWithHost as ot, ObligationThresholds as p, turnResultsBatch as pa, SubmissionStatus_d_exports as pi, SettlementFinalization as pn, DurableWorkerFailure as pr, AdmissionFence as pt, RecoveryEvidence as q, subagentRequestedRecordId as qi, ApprovalSuspensionError as qn, ThreadReadRequest as qr, MarkUnknownRequest as qt, ExplainedSubmission as r, toolCallUnknownRecordId as ra, ThreadTail as ri, RenewOwnershipRequest as rn, DurableObserveOptions as rr, ResumeWaitingParent as rt, IntegrityCheckStatus as s, turnBatchId as sa, getRunInput as si, ResolutionCompletedWithResult as sn, DurableRuntimeConfig as sr, classifyRecovery as st, Admin_d_exports as t, toolCallResultBatchId as ta, ThreadStoreFailure as ti, ReleaseChildBudgetRequest as tn, DurableExplainFailure as tr, ResumePendingToolBatch as tt, ObligationEntry as u, turnPreparedBatchId as ua, PendingSubmission as ui, RevertJoiningRequest as un, DurableSubmitFailure as ur, AbortIntentRequest as ut, RetryRefusalReason as v, AgentRegistration_d_exports as va, RunJournal_d_exports as vi, SubmissionLedgerFailure as vn, RecoverySweepOptions as vr, AdmissionRequest as vt, AppendReservedSettlement as w, ExecutableAgentBinding as wa, compactionBatchId as wi, SubmissionState as wn, threadCreatedBatchId as wr, ApprovalPendingSuspension as wt, predictRecoveryDisposition as x, BindingUnavailable as xa, approvalDecisionBatchId as xi, SubmissionLookupById as xn, isolateRecovery as xr, ApprovalConflict as xt, RetryRefused as y, AgentAttemptContext as ya, TurnCommitInput as yi, SubmissionLedger_d_exports as yn, RecoverySweepResult as yr, AdmissionResolution as yt, FinalizeLedgerFromHistory as z, runIdForSubmission as zi, submissionAbortBatchId as zn, ThreadExportRequest as zr, InputAppliedMarker as zt };
+//# sourceMappingURL=Admin-C34cVKlT.d.mts.map