effect-agent 0.1.0-beta.15 → 0.1.0-beta.151

package/dist/Records-B5GFWCpn.d.mts

@@ -0,0 +1,1104 @@
+import { d as SubagentReservationAmounts, l as SubagentGrant, o as SubagentDelegationCaps, s as SubagentExecutionFailure, u as SubagentParentLink } from "./SubagentContract-DdT7Cqe6.mjs";
+import { a as Receipt } from "./Receipt-BAHyigAF.mjs";
+import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
+import { c as Selection, l as Snapshot } from "./ToolExposure-r2eOWk4F.mjs";
+import { l as RunUsageSummary, r as ModelCallUsage, s as RunTotals } from "./Usage-Dx0aknfk.mjs";
+import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-CaAkzGHL.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
+import { Schema } from "effect";
+declare namespace Records_d_exports {
+  export { AbortRequested, AbortedSubmissionSettled, AgentUpdateEmitted, ApprovalDecision, BatchId, CURRENT_CANONICAL_SCHEMA_VERSION, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalRecordPayload, CanonicalSequence, CompactionCreated, CompletedSubmissionSettled, DefinitionDigestInput, DefinitionDigests, DeploymentId, Digest, FailedSubmissionSettled, MAX_PERSISTED_JSON_BYTES, MAX_PERSISTED_JSON_COLLECTION_LENGTH, MAX_PERSISTED_JSON_DEPTH, MAX_PERSISTED_JSON_NODES, ModelCompleted, ModelResponseInterrupted, ModelResponseRecorded, ObservationOffset, PeerMessagePrepared, PersistedJson, ProducerEpoch, ProducerId, RecordEnvelope, RecordId, RepairAnnotated, ReplayContract, RunCompleted, RunDurationExhausted, RunFailed, RunPolicyUsageReserved, RunStartedRecord, SettlementFailureDiagnostic, SettlementOutcome, SubagentJoined, SubagentLineageRecorded, SubagentRequested, SubagentStarted, SubmissionSettled, SubmissionSettledRecord, SubtreeBudgetReserved, ThreadCreated, ToolApprovalDecided, ToolApprovalRequested, ToolCallPrepared, ToolCallResolution, ToolCallResolved, ToolCallSettled, ToolCallUnknown, ToolOperation, ToolStepSettled, ToolUnavailable, UserInputRecorded, WorkerAdmission, WorkerContinuation, WorkerInputCompleted, WorkerInputRequested, WorkerOrigin, WorkerOriginRecorded, WorkerReportPrepared, WorkerReportRefused, WorkerReportingIntent, WorkerStopRequested };
+}
+/** Stable identity of one canonical record. */
+declare const RecordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+type RecordId = typeof RecordId.Type;
+/** Stable idempotency identity of one atomic append. */
+declare const BatchId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/BatchId">;
+type BatchId = typeof BatchId.Type;
+/** Identity of the deployment that produced a record. */
+declare const DeploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+type DeploymentId = typeof DeploymentId.Type;
+/** Identity of a fenced canonical-log producer. */
+declare const ProducerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ProducerId">;
+type ProducerId = typeof ProducerId.Type;
+/** SHA-256 digest encoded as lowercase hexadecimal text. */
+declare const Digest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+type Digest = typeof Digest.Type;
+/** Adapter-owned resume cursor. Callers must not parse or synthesize it. */
+declare const ObservationOffset: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ObservationOffset">;
+type ObservationOffset = typeof ObservationOffset.Type;
+/** Gap-free position in one Thread's canonical sequence. */
+declare const CanonicalSequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+type CanonicalSequence = typeof CanonicalSequence.Type;
+/** Monotonic fencing epoch for a Thread producer. */
+declare const ProducerEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+type ProducerEpoch = typeof ProducerEpoch.Type;
+/**
+ * Private failed-Settlement evidence. The summary remains the safe public projection; diagnostic
+ * and context preserve structured causal evidence for authorized operators, never model context.
+ * Optional fields allow reading supported Settlements written before causal capture was available.
+ */
+declare const SettlementFailureDiagnostic: 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;
+}>;
+type SettlementFailureDiagnostic = typeof SettlementFailureDiagnostic.Type;
+declare const MAX_PERSISTED_JSON_DEPTH = 64;
+declare const MAX_PERSISTED_JSON_COLLECTION_LENGTH = 4096;
+declare const MAX_PERSISTED_JSON_NODES = 65536;
+declare const MAX_PERSISTED_JSON_BYTES: number;
+/** Canonical JSON admitted to persisted records and checkpoints under explicit resource limits. */
+declare const PersistedJson: Schema.declare<Schema.Json, Schema.Json>;
+type PersistedJson = typeof PersistedJson.Type;
+declare const DefinitionDigestInput_base: Schema.Class<DefinitionDigestInput, Schema.Struct<{
+  readonly agent: Schema.declare<Schema.Json, Schema.Json>;
+  readonly model: Schema.declare<Schema.Json, Schema.Json>;
+  readonly tools: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/** Schema-owned replay inputs whose individual definitions are incorporated into digests. */
+declare class DefinitionDigestInput extends DefinitionDigestInput_base {}
+declare const ReplayContract_base: Schema.Class<ReplayContract, Schema.Struct<{
+  readonly agent: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  /** Retained for reading earlier admissions; never selects executable code. */
+  readonly agentBehavior: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+  readonly tools: Schema.$Record<Schema.String, Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+}>, {}>;
+/** Admission-time operation fingerprints. Agent fingerprints remain immutable evidence only. */
+declare class ReplayContract extends ReplayContract_base {}
+declare const DefinitionDigests_base: Schema.Class<DefinitionDigests, Schema.Struct<{
+  readonly agent: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly model: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly tools: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly replay: Schema.optionalKey<typeof ReplayContract>;
+}>, {}>;
+/** Digests identify admission exactly; only an unfinished operation needs replay compatibility. */
+declare class DefinitionDigests extends DefinitionDigests_base {}
+declare const ThreadCreated_base: Schema.Class<ThreadCreated, Schema.TaggedStruct<"ThreadCreated", {
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly definitions: typeof DefinitionDigests;
+}>, {}>;
+declare class ThreadCreated extends ThreadCreated_base {}
+declare const UserInputRecorded_base: Schema.Class<UserInputRecorded, Schema.TaggedStruct<"UserInputRecorded", {
+  readonly submissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly kind: Schema.Literals<readonly ["user", "steering", "follow-up"]>;
+  readonly runId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly input: Schema.declare<Schema.Json, Schema.Json>;
+  readonly messageAdmission: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly peerName: Schema.NonEmptyString;
+    readonly sender: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly returnAddress: Schema.Struct<{
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    }>;
+    readonly inReplyTo: Schema.optionalKey<Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>>;
+  }>, Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerCompletion">;
+    readonly budgetExhausted: Schema.Boolean;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly report: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literal<"completed">;
+      readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"Settled">;
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly receipt: typeof Receipt;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+      readonly failure: typeof SubagentExecutionFailure;
+    }>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"WorkerUpdate">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly update: typeof Update;
+  }>]>]>>;
+}>, {}>;
+/**
+ * One recorded Thread input. `submissionId` is present only for durably accepted work;
+ * retained history has no admission or settlement obligation. `kind` identifies the input seam.
+ */
+declare class UserInputRecorded extends UserInputRecorded_base {}
+declare const RunStartedRecord_base: Schema.Class<RunStartedRecord, Schema.TaggedStruct<"RunStarted", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  /** Older private histories cannot prove programmatic accounting and must be reset. */
+  readonly policyAccountingVersion: Schema.Literal<1>;
+  readonly maxDurationMillis: Schema.Finite;
+}>, {}>;
+/** Immutable Run start and per-Attempt duration allowance, before any agent execution. */
+declare class RunStartedRecord extends RunStartedRecord_base {}
+declare const RunDurationExhausted_base: Schema.Class<RunDurationExhausted, Schema.TaggedStruct<"RunDurationExhausted", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+}>, {}>;
+/** An active Attempt exhausted its execution allowance; downtime alone never writes this. */
+declare class RunDurationExhausted extends RunDurationExhausted_base {}
+declare const ModelCompleted_base: Schema.Class<ModelCompleted, Schema.Struct<{
+  readonly _tag: Schema.tag<"ModelCompleted">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly output: Schema.declare<Schema.Json, Schema.Json>;
+  readonly messages: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+}>, {}>;
+/**
+ * Final model output. Immediate history may include the exact encoded Prompt suffix of the
+ * successful Run; durable execution instead journals individual ModelResponseRecorded Turns.
+ */
+declare class ModelCompleted extends ModelCompleted_base {}
+declare const ToolCallSettled_base: Schema.Class<ToolCallSettled, Schema.TaggedStruct<"ToolCallSettled", {
+  readonly toolSelection: Schema.optionalKey<typeof Selection>;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly result: Schema.declare<Schema.Json, Schema.Json>;
+  readonly isFailure: Schema.Boolean;
+  /** Explicit engine evidence, never inferred from Tool result data. */
+  readonly budgetRejected: Schema.optionalKey<Schema.Literal<true>>;
+}>, {}>;
+declare class ToolCallSettled extends ToolCallSettled_base {}
+declare const ToolOperation_base: Schema.Class<ToolOperation, Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly executionClass: Schema.Literals<readonly ["readonly", "idempotent", "uncertain"]>;
+  readonly executionKind: Schema.Literals<readonly ["ordinary", "delegation", "orchestration"]>;
+  readonly replay: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/** Compact execution evidence committed with a declaration, before any handler can start. */
+declare class ToolOperation extends ToolOperation_base {}
+declare const ToolUnavailable_base: Schema.Class<ToolUnavailable, Schema.TaggedStruct<"ToolUnavailable", {
+  readonly toolName: Schema.NonEmptyString;
+  readonly execution: Schema.Literals<readonly ["not-executed", "unavailable"]>;
+  readonly message: Schema.String;
+}>, {}>;
+/** A retired call's runtime result. Unavailable readonly work may already have been observed. */
+declare class ToolUnavailable extends ToolUnavailable_base {}
+declare const ModelResponseRecorded_base: Schema.Class<ModelResponseRecorded, Schema.Struct<{
+  readonly _tag: Schema.tag<"ModelResponseRecorded">;
+  readonly toolOperations: Schema.optionalKey<Schema.$Array<typeof ToolOperation>>;
+  readonly toolParameterRejections: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+    readonly parameters: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly error: Schema.toEncoded<Schema.Struct<{
+      readonly _tag: Schema.tag<"AiError">;
+      readonly module: Schema.String;
+      readonly method: Schema.String;
+      readonly reason: typeof import("effect/unstable/ai/AiError").ToolParameterValidationError;
+    }>>;
+  }>>>;
+  readonly toolExposure: Schema.optionalKey<typeof Snapshot>;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly messages: Schema.declare<Schema.Json, Schema.Json>;
+  readonly messagesDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly runScopedPrefixLength: Schema.optionalKey<Schema.Int>;
+  readonly modelUsage: Schema.optionalKey<Schema.$Array<typeof ModelCallUsage>>;
+  readonly unobservedModelCalls: Schema.optionalKey<Schema.Natural>;
+  readonly inputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly outputTokens: Schema.optionalKey<Schema.Natural>;
+  readonly costMicrousd: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+declare class ModelResponseRecorded extends ModelResponseRecorded_base {}
+declare const ToolCallPrepared_base: Schema.Class<ToolCallPrepared, Schema.TaggedStruct<"ToolCallPrepared", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
+  readonly parametersDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  /** Absent legacy evidence grants no delegation replay authority. */
+  readonly executionKind: Schema.optionalKey<Schema.Literals<readonly ["ordinary", "delegation", "orchestration"]>>;
+  readonly executionClass: Schema.optionalKey<Schema.Literals<readonly ["readonly", "idempotent", "uncertain"]>>;
+  readonly replay: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+}>, {}>;
+/**
+ * One approved uncertain/idempotent ordinary Tool Call made durable BEFORE any handler starts
+ * (durability §10). `parameters` is the Schema-encoded wire form of the declared call and
+ * `parametersDigest` pins it; recovery that sees this record without a matching `ToolCallSettled`
+ * (or `ToolCallUnknown` → `ToolCallResolved`) must reconcile or mark unknown, never silently
+ * replay (DUR-009). Ordinary `readonly`-class Tools never produce this record. Delegation
+ * classification is always prepared, including for a Tool annotated `readonly`.
+ */
+declare class ToolCallPrepared extends ToolCallPrepared_base {}
+declare const RunPolicyUsageReserved_base: Schema.Class<RunPolicyUsageReserved, Schema.TaggedStruct<"RunPolicyUsageReserved", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly programmaticToolCalls: Schema.Natural;
+  readonly finalizationUsed: Schema.Boolean;
+}>, {}>;
+/** Monotonic reservations charged before programmatic execution or grace finalization. */
+declare class RunPolicyUsageReserved extends RunPolicyUsageReserved_base {}
+declare const ToolCallUnknown_base: Schema.Class<ToolCallUnknown, Schema.TaggedStruct<"ToolCallUnknown", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * A durable Unknown Outcome: the external effect of one prepared ordinary Tool Call may have
+ * happened but was not confirmed canonically (DUR-009/DUR-017). It is neither success nor
+ * ordinary failure; automatic continuation stops until an authorized resolution arrives.
+ */
+declare class ToolCallUnknown extends ToolCallUnknown_base {}
+/** How one open/unknown Tool Call was authoritatively closed (DUR-017 resolution audit). */
+declare const ToolCallResolution: Schema.Literals<readonly ["completed-with-result", "failed-with-error", "never-started", "safe-retry"]>;
+type ToolCallResolution = typeof ToolCallResolution.Type;
+declare const ToolCallResolved_base: Schema.Class<ToolCallResolved, Schema.TaggedStruct<"ToolCallResolved", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly resolution: Schema.Literals<readonly ["completed-with-result", "failed-with-error", "never-started", "safe-retry"]>;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * The canonical audit record closing one open or unknown Tool Call: reconciler-recovered supplier
+ * truth or an authorized `resolveUnknown` command. `author`/`reason` make every resolution an
+ * attributable decision (DUR-017); a `completed-with-result` resolution is accompanied by the
+ * per-call `ToolCallSettled` record carrying the recovered result.
+ */
+declare class ToolCallResolved extends ToolCallResolved_base {}
+declare const ToolStepSettled_base: Schema.Class<ToolStepSettled, Schema.TaggedStruct<"ToolStepSettled", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly stepName: Schema.NonEmptyString;
+  readonly output: Schema.declare<Schema.Json, Schema.Json>;
+  readonly outputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/**
+ * One accepted Durable Step result (durability §11): exactly-once-recorded while the Step's
+ * external side effect stays honestly at-least-once-executed. Only success is recorded — a failing
+ * Step body fails into the handler's error channel and re-executes on re-entry. `output` is the
+ * Schema-encoded Step output; `outputDigest` pins it for replay-divergence detection.
+ */
+declare class ToolStepSettled extends ToolStepSettled_base {}
+declare const ToolApprovalRequested_base: Schema.Class<ToolApprovalRequested, Schema.TaggedStruct<"ToolApprovalRequested", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly toolName: Schema.NonEmptyString;
+  readonly parametersDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/**
+ * A canonical approval request for one declared Tool Call (CAP-006, durability §8): with this
+ * record durable, "waiting for explicit approval" is a safe suspension boundary — the resumed
+ * Attempt replays the declared batch instead of re-invoking the model.
+ */
+declare class ToolApprovalRequested extends ToolApprovalRequested_base {}
+/** The two-valued approval decision family shared by canonical records and ledger intents. */
+declare const ApprovalDecision: Schema.Literals<readonly ["approved", "denied"]>;
+type ApprovalDecision = typeof ApprovalDecision.Type;
+declare const ToolApprovalDecided_base: Schema.Class<ToolApprovalDecided, Schema.TaggedStruct<"ToolApprovalDecided", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly decision: Schema.Literals<readonly ["approved", "denied"]>;
+  readonly resolver: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * The canonical decision for one requested approval. Appended by the deciding Attempt (policy
+ * auto-decisions) or by the resuming Attempt after a durable `resolveApproval` intent; it is the
+ * deterministic decision authority for every later Attempt of the same Run.
+ */
+declare class ToolApprovalDecided extends ToolApprovalDecided_base {}
+declare const ModelResponseInterrupted_base: Schema.Class<ModelResponseInterrupted, Schema.TaggedStruct<"ModelResponseInterrupted", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly supersededEpoch: Schema.brand<Schema.Natural, "@effect-agent/thread/ProducerEpoch">;
+  readonly attemptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AttemptId">;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * First-class interruption audit (durability §9): appended by a superseding Attempt before it
+ * re-invokes the model for a Turn whose prior owner died without a complete canonical response.
+ * Duplicate provider cost is thereby possible AND observable in canonical history.
+ */
+declare class ModelResponseInterrupted extends ModelResponseInterrupted_base {}
+declare const CompactionCreated_base: Schema.Class<CompactionCreated, Schema.TaggedStruct<"CompactionCreated", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turn: Schema.Int;
+  readonly kind: Schema.Literals<readonly ["clear-tool-results", "summarize", "rollover"]>;
+  readonly coversThrough: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly summary: Schema.optionalKey<Schema.String>;
+  readonly handoff: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/**
+ * One engine-native compaction committed before the pre-Turn view changes (RUN-026).
+ * `coversThrough` is a Thread record sequence: the projection
+ * renders records at or below it as a summary (`summarize`), a fresh window (`rollover`), or with
+ * cleared tool results (kind `clear-tool-results`), never erasing source
+ * history. The record carries no digest by decision: it is appended by the
+ * fenced owner into the very log it covers, and re-verifying a digest would
+ * re-read the covered range on every wake — the O(history) work compaction
+ * exists to remove. Host-supplied ContextCompactor decisions use this same commit path.
+ * Summaries exceeding BoundedText are rejected before append, never truncated.
+ * `summary` is present exactly for `summarize` records; the projection
+ * treats a summarize record without one as invalid and ignores it fail-safe.
+ */
+declare class CompactionCreated extends CompactionCreated_base {}
+declare const RunFailed_base: Schema.Class<RunFailed, Schema.TaggedStruct<"RunFailed", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly failure: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+declare class RunFailed extends RunFailed_base {}
+declare const RunCompleted_base: Schema.Class<RunCompleted, Schema.Struct<{
+  readonly _tag: Schema.tag<"RunCompleted">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly output: Schema.declare<Schema.Json, Schema.Json>;
+  readonly resultDigest: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
+  readonly runDisposition: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  readonly finishReason: Schema.optionalKey<Schema.Literal<"budget-exhausted">>;
+  readonly exhausted: Schema.optionalKey<Schema.Literals<readonly ["tokens", "tool-calls", "turns"]>>;
+}>, {}>;
+declare class RunCompleted extends RunCompleted_base {}
+declare const RepairAnnotated_base: Schema.Class<RepairAnnotated, Schema.TaggedStruct<"RepairAnnotated", {
+  readonly reason: Schema.String;
+  readonly details: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+declare class RepairAnnotated extends RepairAnnotated_base {}
+/** Terminal outcome family for one accepted Submission (DUR-002). */
+declare const SettlementOutcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+type SettlementOutcome = typeof SettlementOutcome.Type;
+declare const AbortRequested_base: Schema.Class<AbortRequested, Schema.TaggedStruct<"AbortRequested", {
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly author: Schema.NonEmptyString;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * A durable abort command made canonical before the active worker is interrupted (DUR-012).
+ * Repeating the same abort command is idempotent; abort never rewrites a prior terminal outcome.
+ */
+declare class AbortRequested extends AbortRequested_base {}
+declare const SubmissionSettled_base: Schema.Class<SubmissionSettled, Schema.Struct<{
+  readonly _tag: Schema.tag<"SubmissionSettled">;
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  readonly runId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">>;
+  readonly result: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  readonly runDisposition: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  readonly finishReason: Schema.optionalKey<Schema.Literal<"budget-exhausted">>;
+  readonly exhausted: Schema.optionalKey<Schema.Literals<readonly ["tokens", "tool-calls", "turns"]>>;
+  readonly policyLimit: Schema.optionalKey<Schema.Literals<readonly ["turns", "tool-calls", "duration", "usage", "tokens", "cost", "repeated-failures"]>>;
+  readonly usageSummary: Schema.optionalKey<typeof RunUsageSummary>;
+  readonly uncommittedModelUsage: Schema.optionalKey<Schema.$Array<typeof ModelCallUsage>>;
+}>, {}>;
+declare class SubmissionSettled extends SubmissionSettled_base {}
+/** Canonical completed settlement; joined completion may legitimately carry no independent result. */
+type CompletedSubmissionSettled = SubmissionSettled & {
+  readonly outcome: "completed";
+};
+/** Canonical failed settlement; its bounded diagnostic is required and typed. */
+type FailedSubmissionSettled = SubmissionSettled & {
+  readonly outcome: "failed";
+  readonly result: SettlementFailureDiagnostic;
+};
+/** Canonical aborted settlement; abort records intent rather than fabricating a terminal result. */
+type AbortedSubmissionSettled = SubmissionSettled & {
+  readonly outcome: "aborted";
+  readonly result?: never;
+};
+type SubmissionSettledRecord = CompletedSubmissionSettled | FailedSubmissionSettled | AbortedSubmissionSettled;
+/**
+ * Canonical-boundary view of `SubmissionSettled`: `finishReason` is valid
+ * only on a `completed` outcome, `exhausted` only alongside
+ * `finishReason: "budget-exhausted"`, every `failed` outcome requires the exact bounded
+ * `SettlementFailureDiagnostic`, aborted outcomes carry no result, and `policyLimit` only occurs
+ * on a `failed` outcome whose diagnostic carries the `AgentPolicyError` tag. `runDisposition`
+ * occurs only on an ordinary completed settlement with a Run —
+ * so a malformed persisted combination such as
+ * `{ outcome: "failed", finishReason: "budget-exhausted" }` or a
+ * `policyLimit` contradicting `result.errorTag` fails closed at decode
+ * instead of becoming trusted audit history (STORE-006, RUN-011).
+ */
+declare const SubmissionSettledRecord: Schema.refine<SubmissionSettledRecord, typeof SubmissionSettled>;
+declare const SubagentRequested_base: Schema.Class<SubagentRequested, Schema.TaggedStruct<"SubagentRequested", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turnId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/TurnId">;
+  readonly turn: Schema.Int;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly targetDigests: typeof DefinitionDigests;
+  readonly childInput: Schema.declare<Schema.Json, Schema.Json>;
+  readonly childInputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly grantDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly reservationId: Schema.NonEmptyString;
+  readonly reservationDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly childPrincipal: Schema.NonEmptyString;
+  readonly childIdempotencyKey: Schema.NonEmptyString;
+  /** Effective invocation bound, already clamped to the delegation and child Definition. */
+  readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+  readonly policy: Schema.optionalKey<Schema.toCodecJson<typeof AgentPolicy>>;
+  readonly budget: Schema.optionalKey<Schema.Struct<{
+    readonly caps: typeof SubagentDelegationCaps;
+    readonly allocation: typeof SubagentReservationAmounts;
+    readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  }>>;
+  readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+  readonly depth: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/**
+ * PARENT-log record of one durable child establishment request:
+ * the exact parent Tool Call, delegation and target identity, the digests that pin the child's
+ * Binding/input/grant, the fenced budget reservation, and the INTENDED child identity derived
+ * deterministically from the parent Run and Tool Call pair (D4). `childInput` carries the
+ * prepared child input in encoded form (D3) so recovery can complete child admission from this
+ * record alone — no live delegation handler is required. `childPrincipal`/`childIdempotencyKey`
+ * carry the ledger admission scope with the ledger's exact bounds; the layering keeps their
+ * branded Schemas in the ledger port.
+ */
+declare class SubagentRequested extends SubagentRequested_base {}
+declare const SubagentStarted_base: Schema.Class<SubagentStarted, Schema.TaggedStruct<"SubagentStarted", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childReceiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly childRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+}>, {}>;
+/**
+ * PARENT-log record that the intended child exists as accepted work:
+ * the full established child identity. It is appended only after the child Receipt
+ * exists — SUB-017 holds by construction because `childReceiptId` is a required field.
+ */
+declare class SubagentStarted extends SubagentStarted_base {}
+declare const SubagentJoined_base: Schema.Class<SubagentJoined, Schema.TaggedStruct<"SubagentJoined", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childSettlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly childOutcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+  readonly childResultDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly projectedResultDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly usageSummary: Schema.declare<Schema.Json, Schema.Json>;
+  readonly usage: Schema.optionalKey<typeof RunTotals>;
+  readonly delegatedUsage: Schema.optionalKey<typeof RunTotals>;
+  readonly reservationId: Schema.NonEmptyString;
+  readonly finalAccounting: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/**
+ * PARENT-log record of one verified child settlement join:
+ * the child's canonical Settlement identity and outcome, the digests pinning the verified child
+ * result and the bounded projected parent result, the child usage summary, and the FINAL
+ * consumed/released accounting decision for the reservation. It commits in ONE atomic batch with
+ * the parent `ToolCallSettled` record (SUB-019); `beginChildBudgetRelease` replays
+ * `finalAccounting` from this record, so canonical history authorizes the release (DUR-015).
+ */
+declare class SubagentJoined extends SubagentJoined_base {}
+declare const SubagentLineageRecorded_base: Schema.Class<SubagentLineageRecorded, Schema.TaggedStruct<"SubagentLineageRecorded", {
+  readonly parentLink: typeof SubagentParentLink;
+  readonly parentSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childDefinitionDigests: typeof DefinitionDigests;
+  readonly childInputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly grantDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  /** Copied from the canonical request before readiness; restored for every child Attempt. */
+  readonly toolCallAllowance: Schema.optionalKey<Schema.Int>;
+  readonly policy: Schema.optionalKey<Schema.toCodecJson<typeof AgentPolicy>>;
+  readonly budget: Schema.optionalKey<Schema.Struct<{
+    readonly caps: typeof SubagentDelegationCaps;
+    readonly allocation: typeof SubagentReservationAmounts;
+    readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  }>>;
+  readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+}>, {}>;
+/**
+ * CHILD-log immutable lineage: the Parent Link plus the digests that pin
+ * the child's definition, input, and authority grant. It is the first record after the child's
+ * `ThreadCreated` (its own single-record batch, so the generic `thread-created:{cid}`
+ * batch identity is never contradicted) and the join path verifies it fail-closed — a fabricated
+ * child or parent identity fails Parent Link verification (SUB-004, D10).
+ */
+declare class SubagentLineageRecorded extends SubagentLineageRecorded_base {}
+declare const WorkerReportingIntent: Schema.Struct<{
+  /** Absent only in historical custom-report origins; these remain readable as evidence. */
+  readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+  readonly sourceDigests: typeof DefinitionDigests;
+  /** Historical custom destination evidence. New worker origins never write this field. */
+  readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+  /** Frozen by the sender before acceptance. Standard emission never reads the source runtime. */
+  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>;
+    /** Encoded to bound recursive worker origins at the admission boundary. */
+    readonly workerAdmission: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+  }>>;
+}>;
+/** Exact successful predecessor evidence; a locator alone grants no authority. */
+declare const WorkerContinuation: 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">;
+}>;
+type WorkerContinuation = typeof WorkerContinuation.Type;
+/** Immutable worker Thread origin. Each input has its own digest and parameters separately. */
+declare const WorkerOrigin: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly source: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"tool">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"programmatic">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>]>;
+  /** A new assignment may continue this completed, immutable predecessor. */
+  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">;
+  }>>;
+  /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+  readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+  /** Frozen at worker creation; older origins remain reusable. */
+  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;
+  /** Exact source registration owns projection; absence means reporting was not declared. */
+  readonly reporting: Schema.optionalKey<Schema.Struct<{
+    /** Absent only in historical custom-report origins; these remain readable as evidence. */
+    readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+    readonly sourceDigests: typeof DefinitionDigests;
+    /** Historical custom destination evidence. New worker origins never write this field. */
+    readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+    /** Frozen by the sender before acceptance. Standard emission never reads the source runtime. */
+    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>;
+      /** Encoded to bound recursive worker origins at the admission boundary. */
+      readonly workerAdmission: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+    }>>;
+  }>>;
+}>;
+type WorkerOrigin = typeof WorkerOrigin.Type;
+/** Frozen per-input metadata; it grants no attached-child or parent-abort semantics. */
+declare const WorkerAdmission: Schema.Struct<{
+  readonly origin: Schema.Struct<{
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"tool">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"programmatic">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>]>;
+    /** A new assignment may continue this completed, immutable predecessor. */
+    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">;
+    }>>;
+    /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+    readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+    /** Frozen at worker creation; older origins remain reusable. */
+    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;
+    /** Exact source registration owns projection; absence means reporting was not declared. */
+    readonly reporting: Schema.optionalKey<Schema.Struct<{
+      /** Absent only in historical custom-report origins; these remain readable as evidence. */
+      readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+      readonly sourceDigests: typeof DefinitionDigests;
+      /** Historical custom destination evidence. New worker origins never write this field. */
+      readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+      /** Frozen by the sender before acceptance. Standard emission never reads the source runtime. */
+      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>;
+        /** Encoded to bound recursive worker origins at the admission boundary. */
+        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;
+  /** Host-bound source input whose subtree funds this input; never chosen by a model. */
+  readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  /** Enables routed receipt lookup when the delivery is owned by a reporting child. */
+  readonly deliveryPrincipal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+  /** Proven framework updates use a separate bounded input-capacity partition. */
+  readonly reportKind: Schema.optionalKey<Schema.Literal<"update">>;
+}>;
+type WorkerAdmission = typeof WorkerAdmission.Type;
+declare const WorkerStopRequested_base: Schema.Class<WorkerStopRequested, Schema.TaggedStruct<"WorkerStopRequested", {
+  readonly command: 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 idempotencyKey: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  }>;
+}>, {}>;
+/** Owner command retained before the destination inbox is sealed. */
+declare class WorkerStopRequested extends WorkerStopRequested_base {}
+declare const WorkerInputRequested_base: Schema.Class<WorkerInputRequested, Schema.TaggedStruct<"WorkerInputRequested", {
+  readonly admission: Schema.Struct<{
+    readonly origin: Schema.Struct<{
+      readonly worker: Schema.Struct<{
+        readonly schemaVersion: Schema.Literal<1>;
+        readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+        readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>;
+      readonly source: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literal<"tool">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+        readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+        readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+      }>, Schema.Struct<{
+        readonly _tag: Schema.Literal<"programmatic">;
+        readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+        readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      }>]>;
+      /** A new assignment may continue this completed, immutable predecessor. */
+      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">;
+      }>>;
+      /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+      readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+      /** Frozen at worker creation; older origins remain reusable. */
+      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;
+      /** Exact source registration owns projection; absence means reporting was not declared. */
+      readonly reporting: Schema.optionalKey<Schema.Struct<{
+        /** Absent only in historical custom-report origins; these remain readable as evidence. */
+        readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+        readonly sourceDigests: typeof DefinitionDigests;
+        /** Historical custom destination evidence. New worker origins never write this field. */
+        readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+        /** Frozen by the sender before acceptance. Standard emission never reads the source runtime. */
+        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>;
+          /** Encoded to bound recursive worker origins at the admission boundary. */
+          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;
+    /** Host-bound source input whose subtree funds this input; never chosen by a model. */
+    readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+    /** Enables routed receipt lookup when the delivery is owned by a reporting child. */
+    readonly deliveryPrincipal: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">>;
+    /** Proven framework updates use a separate bounded input-capacity partition. */
+    readonly reportKind: Schema.optionalKey<Schema.Literal<"update">>;
+  }>;
+  readonly inputDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+}>, {}>;
+/** Source-log capacity reservation, retained independently of the source Run's settlement. */
+declare class WorkerInputRequested extends WorkerInputRequested_base {}
+declare const WorkerOriginRecorded_base: Schema.Class<WorkerOriginRecorded, Schema.TaggedStruct<"WorkerOriginRecorded", {
+  readonly origin: Schema.Struct<{
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly source: Schema.Union<readonly [Schema.Struct<{
+      readonly _tag: Schema.Literal<"tool">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+      readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+    }>, Schema.Struct<{
+      readonly _tag: Schema.Literal<"programmatic">;
+      readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>]>;
+    /** A new assignment may continue this completed, immutable predecessor. */
+    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">;
+    }>>;
+    /** Omitted retains source-subtree funding; worker-run renews only for a new native Run. */
+    readonly budgetScope: Schema.optionalKey<Schema.Literals<readonly ["source-subtree", "worker-run"]>>;
+    /** Frozen at worker creation; older origins remain reusable. */
+    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;
+    /** Exact source registration owns projection; absence means reporting was not declared. */
+    readonly reporting: Schema.optionalKey<Schema.Struct<{
+      /** Absent only in historical custom-report origins; these remain readable as evidence. */
+      readonly mode: Schema.optionalKey<Schema.Literal<"standard">>;
+      readonly sourceDigests: typeof DefinitionDigests;
+      /** Historical custom destination evidence. New worker origins never write this field. */
+      readonly destinationDelegationId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">>;
+      /** Frozen by the sender before acceptance. Standard emission never reads the source runtime. */
+      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>;
+        /** Encoded to bound recursive worker origins at the admission boundary. */
+        readonly workerAdmission: Schema.optionalKey<Schema.declare<Schema.Json, Schema.Json>>;
+      }>>;
+    }>>;
+  }>;
+}>, {}>;
+/** Child-log origin, reconstructed from a retained delivery before the child becomes ready. */
+declare class WorkerOriginRecorded extends WorkerOriginRecorded_base {}
+declare const WorkerInputCompleted_base: Schema.Class<WorkerInputCompleted, Schema.TaggedStruct<"WorkerInputCompleted", {
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly workerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly submissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly completedAtMillis: Schema.Natural;
+  /** New acknowledgements prove that this input's external effects are resolved. */
+  readonly effectsResolved: Schema.optionalKey<Schema.Literal<true>>;
+}>, {}>;
+/** Canonical child completion acknowledgement releases only this input's active capacity. */
+declare class WorkerInputCompleted extends WorkerInputCompleted_base {}
+declare const WorkerReportPrepared_base: Schema.Class<WorkerReportPrepared, Schema.TaggedStruct<"WorkerReportPrepared", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly envelope: Schema.declare<Schema.Json, Schema.Json>;
+  readonly createdAtMillis: Schema.Natural;
+  readonly deadlineAtMillis: Schema.Natural;
+  readonly predecessor: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">>;
+}>, {}>;
+/**
+ * Frozen report decision for one actual Run, shared by every joined Receipt. The envelope is
+ * a Schema-encoded PreparedInput, validated before append and decoded again on recovery.
+ * Keeping the encoded value here avoids a Records/PreparedInput schema dependency cycle.
+ */
+declare class WorkerReportPrepared extends WorkerReportPrepared_base {}
+declare const AgentUpdateEmitted_base: Schema.Class<AgentUpdateEmitted, Schema.TaggedStruct<"AgentUpdateEmitted", {
+  readonly update: typeof Update;
+  readonly definitions: typeof DefinitionDigests;
+  readonly delivery: Schema.optionalKey<Schema.Struct<{
+    readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    readonly envelope: Schema.declare<Schema.Json, Schema.Json>;
+    readonly createdAtMillis: Schema.Natural;
+    readonly deadlineAtMillis: Schema.Natural;
+    readonly predecessor: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">>;
+  }>>;
+}>, {}>;
+/** Accepted update and its optional frozen parent delivery are one atomic canonical fact. */
+declare class AgentUpdateEmitted extends AgentUpdateEmitted_base {}
+declare const WorkerReportRefused_base: Schema.Class<WorkerReportRefused, Schema.TaggedStruct<"WorkerReportRefused", {
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly reason: Schema.Literals<readonly ["filtered", "declaration-unavailable", "destination", "projection", "input", "preparation", "timeout", "defect", "expired", "denied", "capacity"]>;
+}>, {}>;
+/** Permanent bounded report refusal. Application errors and raw Run dispositions stay private. */
+declare class WorkerReportRefused extends WorkerReportRefused_base {}
+declare const PeerMessagePrepared_base: Schema.Class<PeerMessagePrepared, Schema.TaggedStruct<"PeerMessagePrepared", {
+  readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+  readonly sourcePrincipal: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/Principal">;
+  readonly operation: Schema.Literals<readonly ["send", "reply"]>;
+  readonly deadlineAtMillis: Schema.Int;
+  readonly encodedEnvelope: Schema.declare<Schema.Json, Schema.Json>;
+}>, {}>;
+/** Frozen source proof of peer provenance, readable through routed canonical storage. */
+declare class PeerMessagePrepared extends PeerMessagePrepared_base {}
+declare const SubtreeBudgetReserved_base: Schema.Class<SubtreeBudgetReserved, Schema.TaggedStruct<"SubtreeBudgetReserved", {
+  readonly reservationId: Schema.NonEmptyString;
+  readonly sourceSubmissionId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">>;
+  readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly lifetime: Schema.Literals<readonly ["attached", "background"]>;
+  readonly depth: Schema.Int;
+  readonly policy: Schema.toCodecJson<typeof AgentPolicy>;
+  readonly grant: typeof SubagentGrant;
+  readonly budget: Schema.Struct<{
+    readonly caps: typeof SubagentDelegationCaps;
+    readonly allocation: typeof SubagentReservationAmounts;
+    readonly descendantInvocations: Schema.optionalKey<Schema.Natural>;
+  }>;
+}>, {}>;
+/**
+ * One disjoint subtree slice shared by attached and background children of a source input.
+ * The source keeps its own execution ceiling; descendants spend only the remaining allocation.
+ * Reservations include future descendant slots and never refund, including after interruption.
+ * resultBytes reserves the terminal/projection result, not cumulative Tool output bytes.
+ */
+declare class SubtreeBudgetReserved extends SubtreeBudgetReserved_base {}
+/**
+ * Current private-development canonical payload family. Phase 5 adds the seven durable-Tool tags
+ * (prepared/unknown/resolved/step/approval-request/approval-decision/interrupted) additively; S2
+ * adds the four durable-Subagent tags (requested/started/joined/lineage) additively, so the
+ * envelope keeps `schemaVersion: 1` (P4 precedent for additive payload tags).
+ */
+declare const CanonicalRecordPayload: Schema.Union<readonly [typeof ThreadCreated, typeof UserInputRecorded, typeof RunStartedRecord, typeof RunDurationExhausted, typeof RunPolicyUsageReserved, typeof ModelCompleted, typeof ModelResponseRecorded, typeof ToolCallPrepared, typeof ToolCallSettled, typeof ToolCallUnknown, typeof ToolCallResolved, typeof ToolStepSettled, typeof ToolApprovalRequested, typeof ToolApprovalDecided, typeof ModelResponseInterrupted, typeof CompactionCreated, typeof RunFailed, typeof RunCompleted, typeof AbortRequested, Schema.refine<SubmissionSettledRecord, typeof SubmissionSettled>, typeof SubagentRequested, typeof SubagentStarted, typeof SubagentJoined, typeof SubagentLineageRecorded, typeof WorkerInputRequested, typeof WorkerStopRequested, typeof WorkerOriginRecorded, typeof WorkerInputCompleted, typeof WorkerReportPrepared, typeof AgentUpdateEmitted, typeof WorkerReportRefused, typeof PeerMessagePrepared, typeof SubtreeBudgetReserved, typeof RepairAnnotated]>;
+type CanonicalRecordPayload = typeof CanonicalRecordPayload.Type;
+declare const RecordEnvelope_base: Schema.Class<RecordEnvelope, Schema.Struct<{
+  readonly recordId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/RecordId">;
+  readonly family: Schema.Literal<"thread">;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly createdAt: Schema.DateTimeUtcFromString;
+  readonly deploymentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/DeploymentId">;
+  readonly payload: Schema.Union<readonly [typeof ThreadCreated, typeof UserInputRecorded, typeof RunStartedRecord, typeof RunDurationExhausted, typeof RunPolicyUsageReserved, typeof ModelCompleted, typeof ModelResponseRecorded, typeof ToolCallPrepared, typeof ToolCallSettled, typeof ToolCallUnknown, typeof ToolCallResolved, typeof ToolStepSettled, typeof ToolApprovalRequested, typeof ToolApprovalDecided, typeof ModelResponseInterrupted, typeof CompactionCreated, typeof RunFailed, typeof RunCompleted, typeof AbortRequested, Schema.refine<SubmissionSettledRecord, typeof SubmissionSettled>, typeof SubagentRequested, typeof SubagentStarted, typeof SubagentJoined, typeof SubagentLineageRecorded, typeof WorkerInputRequested, typeof WorkerStopRequested, typeof WorkerOriginRecorded, typeof WorkerInputCompleted, typeof WorkerReportPrepared, typeof AgentUpdateEmitted, typeof WorkerReportRefused, typeof PeerMessagePrepared, typeof SubtreeBudgetReserved, typeof RepairAnnotated]>;
+}>, {}>;
+/**
+ * Versioned record envelope stored in an atomic batch. Thread ordering is assigned only
+ * when the batch is committed.
+ */
+declare class RecordEnvelope extends RecordEnvelope_base {}
+/** Backward-compatible domain name for a canonical record. */
+declare const CanonicalRecord: typeof RecordEnvelope;
+type CanonicalRecord = RecordEnvelope;
+declare const CanonicalBatch_base: Schema.Class<CanonicalBatch, Schema.Struct<{
+  readonly batchId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/BatchId">;
+  readonly producerId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ProducerId">;
+  readonly records: Schema.NonEmptyArray<typeof RecordEnvelope>;
+}>, {}>;
+/** One non-empty, bounded, idempotent atomic append unit. */
+declare class CanonicalBatch extends CanonicalBatch_base {}
+declare const CanonicalRecordEnvelope_base: Schema.Class<CanonicalRecordEnvelope, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly batchId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/BatchId">;
+  readonly sequence: Schema.brand<Schema.Natural, "@effect-agent/thread/CanonicalSequence">;
+  readonly offset: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/ObservationOffset">;
+  readonly record: typeof RecordEnvelope;
+}>, {}>;
+/**
+ * A committed record with its Thread ordering and opaque resumable observation cursor.
+ */
+declare class CanonicalRecordEnvelope extends CanonicalRecordEnvelope_base {}
+declare const CURRENT_CANONICAL_SCHEMA_VERSION: 1;
+//#endregion
+export { ToolCallPrepared as $, ProducerId as A, RunStartedRecord as B, ModelCompleted as C, PeerMessagePrepared as D, ObservationOffset as E, ReplayContract as F, SubagentRequested as G, SettlementOutcome as H, RunCompleted as I, SubmissionSettledRecord as J, SubagentStarted as K, RunDurationExhausted as L, RecordId as M, Records_d_exports as N, PersistedJson as O, RepairAnnotated as P, ToolApprovalRequested as Q, RunFailed as R, MAX_PERSISTED_JSON_NODES as S, ModelResponseRecorded as T, SubagentJoined as U, SettlementFailureDiagnostic as V, SubagentLineageRecorded as W, ThreadCreated as X, SubtreeBudgetReserved as Y, ToolApprovalDecided as Z, Digest as _, WorkerStopRequested as _t, BatchId as a, ToolStepSettled as at, MAX_PERSISTED_JSON_COLLECTION_LENGTH as b, CanonicalRecord as c, WorkerAdmission as ct, CanonicalSequence as d, WorkerInputRequested as dt, ToolCallResolution as et, CompactionCreated as f, WorkerOrigin as ft, DeploymentId as g, WorkerReportingIntent as gt, DefinitionDigests as h, WorkerReportRefused as ht, ApprovalDecision as i, ToolOperation as it, RecordEnvelope as j, ProducerEpoch as k, CanonicalRecordEnvelope as l, WorkerContinuation as lt, DefinitionDigestInput as m, WorkerReportPrepared as mt, AbortedSubmissionSettled as n, ToolCallSettled as nt, CURRENT_CANONICAL_SCHEMA_VERSION as o, ToolUnavailable as ot, CompletedSubmissionSettled as p, WorkerOriginRecorded as pt, SubmissionSettled as q, AgentUpdateEmitted as r, ToolCallUnknown as rt, CanonicalBatch as s, UserInputRecorded as st, AbortRequested as t, ToolCallResolved as tt, CanonicalRecordPayload as u, WorkerInputCompleted as ut, FailedSubmissionSettled as v, ModelResponseInterrupted as w, MAX_PERSISTED_JSON_DEPTH as x, MAX_PERSISTED_JSON_BYTES as y, RunPolicyUsageReserved as z };
+//# sourceMappingURL=Records-B5GFWCpn.d.mts.map