@effect-agent/platform-cloudflare 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { Context, Effect, Layer, Option, Schema } from "effect";
-import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationStore, ConversationStoreError, DefinitionDigests, DigestError, DurableAgentRuntime, DurableBindingFailure, DurableRuntimeConfig, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableSubmitAgent, DurableSubmitOptions, DurableWorkerFailure, FenceRejected, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationDenied, OwnershipLost, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, ResolvedBinding, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler } from "@effect-agent/session";
+import { Context, Crypto, Effect, Layer, Option, Schema, Scope } from "effect";
+import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationStore, ConversationStoreError, DefinitionDigests, DigestError, DurableAgentRuntime, DurableBindingFailure, DurableRuntimeConfig, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableSubmitAgent, DurableSubmitOptions, DurableWorkerFailure, FenceRejected, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizerService, OperationDenied, OwnershipLost, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, ResolvedBinding, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler } from "@effect-agent/session";
 import { ConversationPortTransport, DoStorageFailpointHandler, DoStorageInitializationError } from "@effect-agent/storage-cloudflare";
 import { AgentInputError, ConversationId } from "@effect-agent/core";
 import { DurableObjectState as DurableObjectState$1, WorkerEnvironment } from "effect-cf";
@@ -31,6 +31,10 @@ interface ConversationObjectRpc extends Rpc.DurableObjectBranded {
   submitEncoded(encoded: unknown): Promise<unknown>;
   /** Wake-hinted, poll-guaranteed settlement wait; answers an `AwaitSettlementResponse`. */
   awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
+  /** Event-driven durable progress wait; answers a `ProgressObserved` host response. */
+  awaitProgressEncoded(encoded: unknown): Promise<unknown>;
+  /** Best-effort cancellation for one in-flight progress wait. */
+  cancelProgressEncoded(encoded: unknown): Promise<unknown>;
   /** One bounded page of canonical records; answers an `ObservePageResponse`. */
   observePage(encoded: unknown): Promise<unknown>;
   /** Durable abort intent; answers an `AbortResponse`. */
@@ -195,11 +199,10 @@ declare const DurableAlarmError_base: Schema.Class<DurableAlarmError, Schema.Tag
  * and abort re-checks, retry backoff) multiplexes into one idempotent maintenance pass, and
  * the slot always holds the EARLIEST deadline any caller asked for.
  *
- * The alarm invariant (plan §1.4): committed nonterminal work implies a committed alarm.
- * It is established by pre-arming — every mutating entry point and every pass arms the alarm
- * BEFORE its durable mutations — so an eviction at any failpoint leaves a persisted alarm
- * that workerd re-delivers to a fresh incarnation WITHOUT any incoming request. Spurious
- * alarms are harmless by design: a pass over an all-settled lane simply deletes the slot.
+ * The alarm invariant (plan §1.4): every committed actionable mutation carries a newer durable
+ * maintenance generation and a committed alarm. Stable externally-driven waits may be
+ * nonterminal without retaining an alarm; their resolving mutation advances the generation and
+ * restores the alarm atomically.
  */
 /** The Durable Object alarm API failed; surfaces on host entry points as a typed refusal. */
 declare class DurableAlarmError extends DurableAlarmError_base {}
@@ -220,17 +223,16 @@ declare const DurableAlarmService_base: Context.ServiceClass<DurableAlarmService
    * caused, and routing open uncertain-class Tool Calls into spurious Unknown Outcomes.
    * Deferral is contract-safe: wakes are droppable hints, every mutating entry point
    * pre-arms BEFORE its first durable mutation (the alarm invariant never rests on this
-   * call), and the deferred wake is flushed when the pass completes.
+   * call). The pass's durable generation check observes any racing mutation, so the
+   * in-memory hint does not need to be flushed after a stable wait is acknowledged.
    */
   readonly scheduleNow: Effect.Effect<void, DurableAlarmError>;
   /**
-   * Run one maintenance pass with wake deferral (see `scheduleNow`): `scheduleNow` calls
-   * while `body` executes coalesce into one flag, flushed as an immediate re-arm after the
-   * pass — failures of the flush are logged and swallowed (hints are droppable; the pass's
-   * own re-arm policy already bounded the next delivery).
+   * Run one maintenance pass with wake deferral (see `scheduleNow`). Calls made while `body`
+   * executes are droppable promptness hints; correctness rests on the durable generation.
    */
   readonly withWakesDeferred: <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-  /** Clear the slot; only the maintenance pass does this, and only when all work settled. */
+  /** Clear the slot; correctness-sensitive clears live in maintenance generation transactions. */
   readonly cancel: Effect.Effect<void, DurableAlarmError>;
 }>;
 /** `ctx.storage` alarm slot as an Effect service; storage is truth, never a memory field. */
@@ -238,57 +240,60 @@ declare class DurableAlarmService extends DurableAlarmService_base {
   static readonly layer: Layer.Layer<DurableAlarmService, never, DurableObjectContext>;
 }
 declare const MaintenancePassReport_base: Schema.Class<MaintenancePassReport, Schema.Struct<{
+  /** `caught-up` is generation-only; `actionable` ran recovery and one bounded drain. */
+  readonly phase: Schema.Literals<readonly ["caught-up", "actionable"]>;
   /** Recovery decisions executed (or deferred) BEFORE any new claim in this pass. */
   readonly recovered: Schema.Int;
   /** Settlements the drain pass finalized. */
   readonly settled: Schema.Int;
   /** Submissions still nonterminal after the pass (suspended/unknown lanes stay honest). */
   readonly nonterminal: Schema.Int;
-  /** `rearmed` while nonterminal work remains, `cleared` once everything settled. */
+  /** `rearmed` for dirty/autonomous work, `cleared` for stable waits or settlement. */
   readonly alarm: Schema.Literals<readonly ["rearmed", "cleared"]>;
 }>, {}>;
 /** What one maintenance pass did — auditable evidence mirroring `NodeDurableHost`'s report. */
 declare class MaintenancePassReport extends MaintenancePassReport_base {}
+/** Fault boundaries around every maintenance-owned durable mutation. */
+type ConversationMaintenanceFailpointLocation = "maintenance:dirty:before" | "maintenance:dirty:after" | "maintenance:mutation:armed" | "maintenance:mutation:finished" | "maintenance:ensure:before" | "maintenance:ensure:after" | "maintenance:begin:before" | "maintenance:begin:after" | "maintenance:finish:before" | "maintenance:finish:after";
+type ConversationMaintenanceFailpointHandler = (location: ConversationMaintenanceFailpointLocation) => Effect.Effect<void>;
+declare const ConversationMaintenanceFailpoint_base: Context.ServiceClass<ConversationMaintenanceFailpoint, "@effect-agent/platform-cloudflare/ConversationMaintenanceFailpoint", {
+  readonly hit: ConversationMaintenanceFailpointHandler;
+}>;
+/** Test-only fault authority; production uses the inert layer. */
+declare class ConversationMaintenanceFailpoint extends ConversationMaintenanceFailpoint_base {
+  static readonly layer: Layer.Layer<ConversationMaintenanceFailpoint, never, never>;
+}
 type MaintenancePassFailure = DurableWorkerFailure | DurableBindingFailure | DurableAlarmError;
 declare const ConversationMaintenance_base: Context.ServiceClass<ConversationMaintenance, "@effect-agent/platform-cloudflare/ConversationMaintenance", {
   /** One idempotent maintenance pass; failures propagate so workerd retries the alarm. */
   readonly pass: Effect.Effect<MaintenancePassReport, MaintenancePassFailure>;
   /**
-   * Defensive half of the alarm invariant, run by the constructor gate: if any local
-   * Submission is nonterminal and no alarm is scheduled, arm one within the scan interval.
-   * Local-only (one ledger scan + the alarm slot) — never a recovery pass, never transport.
+   * Constructor gate: initialize/inspect only the O(1) maintenance record and ensure a dirty
+   * generation has an alarm. It never scans the ledger or canonical history.
    */
   readonly ensureAlarm: Effect.Effect<void, MaintenancePassFailure>;
   /**
-   * The pre-arm every mutating entry point runs BEFORE its first durable mutation: with
-   * the alarm committed first, a committed admission (or any other committed nonterminal
-   * transition) can never be observed without the alarm that will finish it.
+   * Serialize the pre-arm boundary with pass acknowledgement, advance the durable dirty
+   * generation and arm the alarm in one transaction BEFORE running the caller's mutation.
+   * A pass cannot acknowledge while that mutation remains in flight.
    */
-  readonly preArm: Effect.Effect<void, DurableAlarmError>;
+  readonly withMutation: <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | DurableAlarmError, R>;
 }>;
 /**
- * The idempotent maintenance pass and the alarm-invariant helpers (plan §1.4, D-P6-1/2).
- *
- * `pass` = pre-arm → `runRecovery` → `processConversationResolved` → re-arm-or-clear:
+ * Incremental, quiescent maintenance over a durable dirty/processed generation (issue #93).
  *
- * 1. **Pre-arm**: the alarm is re-armed at `now + wakeScanInterval` BEFORE any work, so an
- *    eviction (or thrown failure → workerd alarm retry) at any point of the pass leaves a
- *    committed alarm and the fresh incarnation converges without an incoming request.
- * 2. **Reconcile before new work** (exit gate): every pass classifies and repairs every
- *    nonterminal Submission before the drain claims anything; the pure classifier and the
- *    repair executors are idempotent, so at-least-once alarm delivery re-runs them safely.
- * 3. **Drain**: one bounded `processConversationResolved` pass over this Object's lane — the
- *    D-P6-1 shape; no infinite `runResolvedWorker` loop ever pins the Object.
- * 4. **Re-arm policy**: nonterminal work re-arms at `now + min(backoff-with-jitter,
- *    wakeScanInterval)` — the scan interval bounds every wait (lease expiry of a dead
- *    incarnation included, since claims retry each pass) and the backoff (reset on progress,
- *    grown otherwise) keeps stuck lanes from busy-spinning; all settled clears the slot.
+ * `pass` = generation snapshot/pre-arm → recovery → bounded drain → generation acknowledgement:
  *
- * Every step is a durability-protocol step that already tolerates re-execution, which is
- * what makes double-fired alarms harmless (the alarm.test.ts gate).
+ * 1. One storage transaction reads dirty/processed and re-arms before work. A caught-up forced
+ *    alarm takes an O(1) path without recovery, ledger scans, or canonical-history reads.
+ * 2. Recovery still strictly precedes a new claim, and one bounded drain advances the lane.
+ * 3. The final transaction acknowledges only the generation observed at pass start. A racing
+ *    mutation therefore remains `dirty > processed` and retains its atomically-established alarm.
+ * 4. Stable external waits acknowledge and clear. Autonomous retry, indeterminate, and lease
+ *    recovery states leave their generation dirty and retain bounded backoff rearming.
  */
 declare class ConversationMaintenance extends ConversationMaintenance_base {
-  static readonly layer: Layer.Layer<ConversationMaintenance, never, DurableAgentRuntime | AgentBindingResolver | SubmissionLedger | DurableAlarmService | CloudflareDurableRuntimeConfig | ConversationObjectIdentity>;
+  static readonly layer: Layer.Layer<ConversationMaintenance, never, DurableAgentRuntime | AgentBindingResolver | SubmissionLedger | DurableAlarmService | ConversationMaintenanceFailpoint | CloudflareDurableRuntimeConfig | ConversationObjectIdentity | DurableObjectContext>;
 }
 //#endregion
 //#region src/wake-scheduler.d.ts
@@ -306,6 +311,22 @@ declare class ConversationMaintenance extends ConversationMaintenance_base {
  */
 declare const cloudflareWakeSchedulerLayer: Layer.Layer<WakeScheduler, never, DurableAlarmService | ConversationObjectIdentity | ConversationObjectNamespace>;
 //#endregion
+//#region src/progress-wait.d.ts
+declare const ProgressWaitRegistry_base: Context.ServiceClass<ProgressWaitRegistry, "@effect-agent/platform-cloudflare/ProgressWaitRegistry", {
+  /** Register a Scope-owned cancellation signal, observing any early cancel tombstone. */
+  readonly subscribe: (waiterId: string) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;
+  /** Cancel a registered waiter, or remember a bounded early cancellation. */
+  readonly cancel: (waiterId: string) => Effect.Effect<void>;
+}>;
+/**
+ * Per-incarnation cancellation registry for long-lived progress RPCs. The public runtime owns
+ * the actual wake registration; this host-only registry lets an interrupted Worker Effect ask
+ * the Object to interrupt its scoped wait before the Worker execution context itself ends.
+ */
+declare class ProgressWaitRegistry extends ProgressWaitRegistry_base {
+  static readonly layer: Layer.Layer<ProgressWaitRegistry>;
+}
+//#endregion
 //#region src/transport.d.ts
 /**
  * `ConversationPortTransport` over native Durable Object JS RPC (decision D-P6-3): one
@@ -367,6 +388,10 @@ interface CloudflareDurableRuntimeOptions {
   readonly storageFailpoint?: ((ctx: DurableObjectState) => DoStorageFailpointHandler) | undefined;
   /** Coordinator fault injection (`submit:*` / `terminalize:*` locations); default none. */
   readonly runtimeFailpoint?: ((ctx: DurableObjectState) => DurableRuntimeFailpointHandler) | undefined;
+  /** Conversation-maintenance generation/alarm fault injection; default none. */
+  readonly maintenanceFailpoint?: ((ctx: DurableObjectState) => ConversationMaintenanceFailpointHandler) | undefined;
+  /** Host-supplied fail-closed authorization policy; defaults to service possession. */
+  readonly operationAuthorizer?: OperationAuthorizerService | undefined;
   /**
    * Reconciliation policy consulted for open ordinary Tool Calls before an Unknown Outcome
    * is recorded (durability §10, DUR-009). Defaults to the fail-closed
@@ -397,7 +422,7 @@ type CloudflareBindingSource = ReadonlyArray<ResolvedBinding> | Effect.Effect<Re
 /** Every construction failure of the assembled Cloudflare durable runtime stack. */
 type CloudflareDurableRuntimeInitializationError = CloudflarePlatformConfigError | DoStorageInitializationError;
 /** The services `CloudflareDurableRuntime.layer` provides. */
-type CloudflareDurableRuntimeServices = DurableAgentRuntime | SubmissionLedger | ConversationStore | WakeScheduler | DurableRuntimeConfig | AgentBindingResolver | CloudflareDurableRuntimeConfig | ConversationObjectIdentity | DurableAlarmService | ConversationMaintenance | ConversationObjectPorts;
+type CloudflareDurableRuntimeServices = DurableAgentRuntime | SubmissionLedger | ConversationStore | WakeScheduler | DurableRuntimeConfig | AgentBindingResolver | CloudflareDurableRuntimeConfig | ConversationObjectIdentity | DurableAlarmService | ConversationMaintenance | ConversationObjectPorts | ProgressWaitRegistry;
 declare const ConversationObjectPorts_base: Context.ServiceClass<ConversationObjectPorts, "@effect-agent/platform-cloudflare/ConversationObjectPorts", {
   readonly handle: (encoded: unknown) => Effect.Effect<unknown>;
 }>;
@@ -444,6 +469,10 @@ declare const ConversationClientError_base: Schema.Class<ConversationClientError
   readonly conversationId: Schema.String;
   readonly message: Schema.String;
   readonly cause: Schema.optionalKey<Schema.Defect>;
+  /** Cloudflare's own classification for a failure safe to retry with a fresh stub. */
+  readonly retryable: Schema.optionalKey<Schema.Boolean>;
+  /** Cloudflare overloads are surfaced immediately instead of adding retry pressure. */
+  readonly overloaded: Schema.optionalKey<Schema.Boolean>;
 }>, import("effect/Cause").YieldableError>;
 /** The Worker-side stub call itself failed (RPC rejection, overload, eviction mid-call). */
 declare class ConversationClientError extends ConversationClientError_base {}
@@ -467,13 +496,24 @@ declare const ObservePageRequest_base: Schema.Class<ObservePageRequest, Schema.S
 }>, {}>;
 /** One bounded page of canonical records after an optional sequence. */
 declare class ObservePageRequest extends ObservePageRequest_base {}
+declare const AwaitProgressRequest_base: Schema.Class<AwaitProgressRequest, Schema.Struct<{
+  readonly afterSequence: Schema.brand<Schema.Natural, "@effect-agent/session/CanonicalSequence">;
+  readonly waiterId: Schema.String;
+}>, {}>;
+/** One event-driven wait for canonical progress strictly after this sequence. */
+declare class AwaitProgressRequest extends AwaitProgressRequest_base {}
+declare const CancelProgressRequest_base: Schema.Class<CancelProgressRequest, Schema.Struct<{
+  readonly waiterId: Schema.String;
+}>, {}>;
+/** Best-effort cancellation of one in-flight progress RPC. */
+declare class CancelProgressRequest extends CancelProgressRequest_base {}
 /**
  * Every typed failure a host entry point can produce, plus the protocol's own errors. Same
  * closed-union discipline as the WP2 `PortFailure`: members re-decode to the SAME tagged
  * classes on the Worker side; `cause` chains travel as Schema defects without instance
  * fidelity (plan §2.8).
  */
-declare const HostFailure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, typeof SettlementConflict, typeof ApprovalConflict, typeof UnknownResolutionConflict, typeof JoinedToHost, typeof LedgerError, typeof ConversationStoreError, typeof ConversationNotMaterialized, typeof AppendConflict, typeof FenceRejected, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof HostProtocolError]>;
+declare const HostFailure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, typeof SettlementConflict, typeof ApprovalConflict, typeof UnknownResolutionConflict, typeof JoinedToHost, typeof LedgerError, typeof ConversationStoreError, typeof ConversationNotMaterialized, typeof AppendConflict, typeof FenceRejected, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof OperationDenied, typeof HostProtocolError]>;
 type HostFailure = typeof HostFailure.Type;
 declare const SubmitSucceeded_base: Schema.Class<SubmitSucceeded, Schema.TaggedStruct<"SubmitSucceeded", {
   readonly receipt: typeof Receipt;
@@ -487,6 +527,11 @@ declare const ObservedPage_base: Schema.Class<ObservedPage, Schema.TaggedStruct<
   readonly records: Schema.$Array<typeof CanonicalRecordEnvelope>;
 }>, {}>;
 declare class ObservedPage extends ObservedPage_base {}
+declare const ProgressObserved_base: Schema.Class<ProgressObserved, Schema.TaggedStruct<"ProgressObserved", {}>, {}>;
+/** A record was already committed or an incarnation-local hint says the caller should re-read. */
+declare class ProgressObserved extends ProgressObserved_base {}
+declare const ProgressCancelled_base: Schema.Class<ProgressCancelled, Schema.TaggedStruct<"ProgressCancelled", {}>, {}>;
+declare class ProgressCancelled extends ProgressCancelled_base {}
 declare const AbortRecorded_base: Schema.Class<AbortRecorded, Schema.TaggedStruct<"AbortRecorded", {
   readonly intent: typeof AbortIntent;
 }>, {}>;
@@ -500,12 +545,12 @@ declare const UnknownResolutionRecorded_base: Schema.Class<UnknownResolutionReco
 }>, {}>;
 declare class UnknownResolutionRecorded extends UnknownResolutionRecorded_base {}
 declare const HostFailed_base: Schema.Class<HostFailed, Schema.TaggedStruct<"HostFailed", {
-  readonly failure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, typeof SettlementConflict, typeof ApprovalConflict, typeof UnknownResolutionConflict, typeof JoinedToHost, typeof LedgerError, typeof ConversationStoreError, typeof ConversationNotMaterialized, typeof AppendConflict, typeof FenceRejected, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof HostProtocolError]>;
+  readonly failure: Schema.Union<readonly [typeof AgentInputError, typeof DigestError, typeof AdmissionConflict, typeof SettlementConflict, typeof ApprovalConflict, typeof UnknownResolutionConflict, typeof JoinedToHost, typeof LedgerError, typeof ConversationStoreError, typeof ConversationNotMaterialized, typeof AppendConflict, typeof FenceRejected, typeof DurableRuntimeFailpointError, typeof AdmissionLimitExceeded, typeof DurableAlarmError, typeof OperationDenied, typeof HostProtocolError]>;
 }>, {}>;
 /** The entry point failed TYPED on the Object; the failure re-decodes verbatim. */
 declare class HostFailed extends HostFailed_base {}
 /** The uniform answer of one host entry point. Callers narrow by the tag their call implies. */
-declare const HostResponse: Schema.Union<readonly [typeof SubmitSucceeded, typeof SettlementReached, typeof ObservedPage, typeof AbortRecorded, typeof ApprovalRecorded, typeof UnknownResolutionRecorded, typeof HostFailed]>;
+declare const HostResponse: Schema.Union<readonly [typeof SubmitSucceeded, typeof SettlementReached, typeof ObservedPage, typeof ProgressObserved, typeof ProgressCancelled, typeof AbortRecorded, typeof ApprovalRecorded, typeof UnknownResolutionRecorded, typeof HostFailed]>;
 type HostResponse = typeof HostResponse.Type;
 declare const decodeSubmitRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<SubmitRequest, Schema.SchemaError, never>;
 declare const encodeSubmitRequest: (input: SubmitRequest, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
@@ -531,6 +576,15 @@ declare const encodeObservePageRequest: (input: ObservePageRequest, options?: im
   readonly afterSequence?: number | undefined;
   readonly limit: number;
 }, Schema.SchemaError, never>;
+declare const decodeAwaitProgressRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AwaitProgressRequest, Schema.SchemaError, never>;
+declare const encodeAwaitProgressRequest: (input: AwaitProgressRequest, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly afterSequence: number;
+  readonly waiterId: string;
+}, Schema.SchemaError, never>;
+declare const decodeCancelProgressRequest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<CancelProgressRequest, Schema.SchemaError, never>;
+declare const encodeCancelProgressRequest: (input: CancelProgressRequest, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+  readonly waiterId: string;
+}, Schema.SchemaError, never>;
 declare const decodeAbortCommand: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortCommand, Schema.SchemaError, never>;
 declare const encodeAbortCommand: (input: AbortCommand, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
   readonly submissionId: string;
@@ -563,7 +617,7 @@ declare const encodeUnknownResolutionCommand: (input: UnknownResolutionCommand,
     readonly _tag: "AbortSubmission";
   };
 }, Schema.SchemaError, never>;
-declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | SettlementReached | SubmitSucceeded | UnknownResolutionRecorded, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | SubmitSucceeded | UnknownResolutionRecorded, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
   readonly _tag: "SubmitSucceeded";
   readonly receipt: {
     readonly receiptId: string;
@@ -594,42 +648,6 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
       readonly createdAt: string;
       readonly deploymentId: string;
       readonly payload: {
-        readonly _tag: "ToolCallPrepared";
-        readonly runId: string;
-        readonly turnId: string;
-        readonly turn: number;
-        readonly toolCallId: string;
-        readonly toolName: string;
-        readonly parameters: Schema.Json;
-        readonly parametersDigest: string;
-      } | {
-        readonly _tag: "ToolCallUnknown";
-        readonly runId: string;
-        readonly turn: number;
-        readonly toolCallId: string;
-        readonly toolName: string;
-        readonly reason: string;
-      } | {
-        readonly _tag: "ToolApprovalDecided";
-        readonly runId: string;
-        readonly turn: number;
-        readonly toolCallId: string;
-        readonly decision: "approved" | "denied";
-        readonly resolver: string;
-        readonly reason: string;
-      } | {
-        readonly _tag: "ToolCallResolved";
-        readonly runId: string;
-        readonly toolCallId: string;
-        readonly resolution: "completed-with-result" | "failed-with-error" | "never-started" | "safe-retry";
-        readonly author: string;
-        readonly reason: string;
-      } | {
-        readonly _tag: "AbortRequested";
-        readonly submissionId: string;
-        readonly author: string;
-        readonly reason: string;
-      } | {
         readonly _tag: "ConversationCreated";
         readonly agentId: string;
         readonly definitions: {
@@ -657,6 +675,15 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly inputTokens?: number | undefined;
         readonly outputTokens?: number | undefined;
         readonly costMicrousd?: number | undefined;
+      } | {
+        readonly _tag: "ToolCallPrepared";
+        readonly runId: string;
+        readonly turnId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly parameters: Schema.Json;
+        readonly parametersDigest: string;
       } | {
         readonly _tag: "ToolCallSettled";
         readonly runId: string;
@@ -664,6 +691,20 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly toolName: string;
         readonly result: Schema.Json;
         readonly isFailure: boolean;
+      } | {
+        readonly _tag: "ToolCallUnknown";
+        readonly runId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly toolName: string;
+        readonly reason: string;
+      } | {
+        readonly _tag: "ToolCallResolved";
+        readonly runId: string;
+        readonly toolCallId: string;
+        readonly resolution: "completed-with-result" | "failed-with-error" | "never-started" | "safe-retry";
+        readonly author: string;
+        readonly reason: string;
       } | {
         readonly _tag: "ToolStepSettled";
         readonly runId: string;
@@ -679,6 +720,14 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly toolCallId: string;
         readonly toolName: string;
         readonly parametersDigest: string;
+      } | {
+        readonly _tag: "ToolApprovalDecided";
+        readonly runId: string;
+        readonly turn: number;
+        readonly toolCallId: string;
+        readonly decision: "approved" | "denied";
+        readonly resolver: string;
+        readonly reason: string;
       } | {
         readonly _tag: "ModelResponseInterrupted";
         readonly runId: string;
@@ -700,6 +749,11 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
         readonly _tag: "RunCompleted";
         readonly runId: string;
         readonly output: Schema.Json;
+      } | {
+        readonly _tag: "AbortRequested";
+        readonly submissionId: string;
+        readonly author: string;
+        readonly reason: string;
       } | {
         readonly _tag: "SubmissionSettled";
         readonly submissionId: string;
@@ -777,6 +831,10 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
       };
     };
   }[];
+} | {
+  readonly _tag: "ProgressObserved";
+} | {
+  readonly _tag: "ProgressCancelled";
 } | {
   readonly _tag: "AbortRecorded";
   readonly intent: {
@@ -821,18 +879,50 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
 } | {
   readonly _tag: "HostFailed";
   readonly failure: {
-    readonly _tag: "LedgerError";
-    readonly operation: string;
+    readonly _tag: "HostProtocolError";
+    readonly message: string;
+  } | {
+    readonly _tag: "OperationDenied";
+    readonly operation: "explain" | "observe" | "resolveApproval" | "resolveUnknown" | "retry" | "scanObligations" | "verify" | "wake";
+    readonly reason: string;
+    readonly conversationId?: string | undefined;
+    readonly submissionId?: string | undefined;
+  } | {
+    readonly _tag: "AgentInputError";
     readonly message: string;
-    readonly cause?: Schema.Json | undefined;
   } | {
     readonly _tag: "DigestError";
     readonly message: string;
     readonly cause?: Schema.Json | undefined;
+  } | {
+    readonly _tag: "AdmissionConflict";
+    readonly conversationId: string;
+    readonly principal: string;
+    readonly idempotencyKey: string;
+    readonly existingInputDigest: string;
+    readonly attemptedInputDigest: string;
   } | {
     readonly _tag: "SettlementConflict";
     readonly submissionId: string;
     readonly existingOutcome: "aborted" | "completed" | "failed";
+  } | {
+    readonly _tag: "ApprovalConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+    readonly existingDecision: "approved" | "denied";
+  } | {
+    readonly _tag: "UnknownResolutionConflict";
+    readonly submissionId: string;
+    readonly toolCallId: string;
+  } | {
+    readonly _tag: "JoinedToHost";
+    readonly submissionId: string;
+    readonly hostSubmissionId: string;
+  } | {
+    readonly _tag: "LedgerError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
   } | {
     readonly _tag: "ConversationStoreError";
     readonly operation: string;
@@ -856,57 +946,37 @@ declare const encodeHostResponse: (input: AbortRecorded | ApprovalRecorded | Hos
   } | {
     readonly _tag: "DurableRuntimeFailpointError";
     readonly location: "abort:after-intent" | "approval:after-request-append" | "approval:after-suspend" | "claim:after-claim" | "compaction:after-canonical-append" | "input:after-canonical-append" | "join:after-canonical-append" | "join:after-claim" | "resolve:after-intent" | "step:after-step-append" | "subagent:after-admit" | "subagent:after-child-abort-intent" | "subagent:after-child-ready" | "subagent:after-join-append" | "subagent:after-release" | "subagent:after-release-pending" | "subagent:after-request-append" | "subagent:after-reserve" | "subagent:after-sibling-settle" | "subagent:after-start-append" | "subagent:after-suspend" | "submit:after-admit" | "submit:after-materialize" | "terminalize:after-canonical-append" | "terminalize:after-reserve" | "tools:after-prepared-append" | "turn:after-canonical-append" | "turn:after-response-append" | "turn:after-results-append";
-  } | {
-    readonly _tag: "DurableAlarmError";
-    readonly operation: string;
-    readonly message: string;
-    readonly cause?: Schema.Json | undefined;
-  } | {
-    readonly _tag: "HostProtocolError";
-    readonly message: string;
-  } | {
-    readonly _tag: "AgentInputError";
-    readonly message: string;
-  } | {
-    readonly _tag: "AdmissionConflict";
-    readonly conversationId: string;
-    readonly principal: string;
-    readonly idempotencyKey: string;
-    readonly existingInputDigest: string;
-    readonly attemptedInputDigest: string;
-  } | {
-    readonly _tag: "ApprovalConflict";
-    readonly submissionId: string;
-    readonly toolCallId: string;
-    readonly existingDecision: "approved" | "denied";
-  } | {
-    readonly _tag: "UnknownResolutionConflict";
-    readonly submissionId: string;
-    readonly toolCallId: string;
-  } | {
-    readonly _tag: "JoinedToHost";
-    readonly submissionId: string;
-    readonly hostSubmissionId: string;
   } | {
     readonly _tag: "AdmissionLimitExceeded";
     readonly limit: "database-bytes" | "input-bytes" | "queue-depth";
     readonly actual: number;
     readonly maximum: number;
+  } | {
+    readonly _tag: "DurableAlarmError";
+    readonly operation: string;
+    readonly message: string;
+    readonly cause?: Schema.Json | undefined;
   };
 }, Schema.SchemaError, never>;
-declare const decodeHostResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | SettlementReached | SubmitSucceeded | UnknownResolutionRecorded, Schema.SchemaError, never>;
+declare const decodeHostResponse: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<AbortRecorded | ApprovalRecorded | HostFailed | ObservedPage | ProgressCancelled | ProgressObserved | SettlementReached | SubmitSucceeded | UnknownResolutionRecorded, Schema.SchemaError, never>;
 /** Failure surface of `CloudflareConversationClient.submit`. */
 type ClientSubmitFailure = AgentInputError | DigestError | AdmissionConflict | LedgerError | ConversationStoreError | ConversationNotMaterialized | AppendConflict | FenceRejected | DurableRuntimeFailpointError | AdmissionLimitExceeded | DurableAlarmError | HostProtocolError | ConversationClientError;
 type ClientAwaitFailure = LedgerError | SettlementConflict | HostProtocolError | ConversationClientError;
-type ClientObserveFailure = ConversationStoreError | ConversationNotMaterialized | HostProtocolError | ConversationClientError;
+type ClientObserveFailure = ConversationStoreError | ConversationNotMaterialized | OperationDenied | HostProtocolError | ConversationClientError;
+type ClientProgressFailure = ConversationStoreError | ConversationNotMaterialized | OperationDenied | HostProtocolError | ConversationClientError;
 type ClientAbortFailure = LedgerError | SettlementConflict | JoinedToHost | DurableRuntimeFailpointError | DurableAlarmError | HostProtocolError | ConversationClientError;
-type ClientApprovalFailure = LedgerError | SettlementConflict | ApprovalConflict | DurableAlarmError | HostProtocolError | ConversationClientError;
-type ClientUnknownFailure = LedgerError | SettlementConflict | UnknownResolutionConflict | JoinedToHost | DurableRuntimeFailpointError | DurableAlarmError | HostProtocolError | ConversationClientError;
+type ClientApprovalFailure = LedgerError | SettlementConflict | ApprovalConflict | OperationDenied | DurableAlarmError | HostProtocolError | ConversationClientError;
+type ClientUnknownFailure = LedgerError | SettlementConflict | UnknownResolutionConflict | JoinedToHost | DurableRuntimeFailpointError | OperationDenied | DurableAlarmError | HostProtocolError | ConversationClientError;
 declare const CloudflareConversationClient_base: Context.ServiceClass<CloudflareConversationClient, "@effect-agent/platform-cloudflare/CloudflareConversationClient", {
   /** Encode the input client-side, then durably submit to the owning Object. */
   readonly submit: <InputSchema extends Schema.Top>(agent: DurableSubmitAgent<InputSchema>, input: InputSchema["Type"], options: DurableSubmitOptions) => Effect.Effect<Receipt, ClientSubmitFailure, InputSchema["EncodingServices"]>;
   /** Wake-hinted, poll-guaranteed settlement wait executed inside the owning Object. */
   readonly awaitSettlement: (receipt: Receipt) => Effect.Effect<Settlement, ClientAwaitFailure>;
+  /**
+   * Wait without polling until progress after `afterSequence` is already durable or hinted.
+   * The result is deliberately void: canonical records remain authoritative and must be read.
+   */
+  readonly awaitProgress: (conversationId: ConversationId, afterSequence: CanonicalSequence) => Effect.Effect<void, ClientProgressFailure>;
   /** One bounded page of canonical records. */
   readonly readPage: (conversationId: ConversationId, options?: {
     readonly afterSequence?: CanonicalSequence | undefined;
@@ -929,7 +999,7 @@ declare const CloudflareConversationClient_base: Context.ServiceClass<Cloudflare
 }>;
 /** Worker-side client over the Conversation Object namespace (DEPLOY-010). */
 declare class CloudflareConversationClient extends CloudflareConversationClient_base {
-  static readonly layer: Layer.Layer<CloudflareConversationClient, never, ConversationObjectNamespace>;
+  static readonly layer: Layer.Layer<CloudflareConversationClient, never, ConversationObjectNamespace | Crypto.Crypto>;
 }
 //#endregion
 //#region src/conversation-object.d.ts
@@ -1478,6 +1548,8 @@ declare const decodeAdminResponse: (input: unknown, options?: import("effect/Sch
 interface ConversationObjectInstance extends DurableObject$1 {
   submitEncoded(encoded: unknown): Promise<unknown>;
   awaitSettlementEncoded(encoded: unknown): Promise<unknown>;
+  awaitProgressEncoded(encoded: unknown): Promise<unknown>;
+  cancelProgressEncoded(encoded: unknown): Promise<unknown>;
   observePage(encoded: unknown): Promise<unknown>;
   abortEncoded(encoded: unknown): Promise<unknown>;
   resolveApprovalEncoded(encoded: unknown): Promise<unknown>;
@@ -1546,5 +1618,5 @@ interface DynamicWorkerCodeExecutorOptions {
 /** Layer building the Dynamic Worker `CodeExecutor` from resolved bindings. */
 declare const dynamicWorkerCodeExecutorLayer: (options: DynamicWorkerCodeExecutorOptions) => Layer.Layer<CodeExecutor>;
 //#endregion
-export { AbortRecorded, AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, AdmissionLimitExceeded, ApprovalRecorded, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, ClientAbortFailure, ClientApprovalFailure, ClientAwaitFailure, ClientObserveFailure, ClientSubmitFailure, ClientUnknownFailure, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareBindingSource, CloudflareBindingSourceContext, CloudflareConversationClient, CloudflareDurableRuntime, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflareDurableRuntimeInitializationError, CloudflareDurableRuntimeOptions, CloudflareDurableRuntimeServices, CloudflarePlatformConfigError, CodeModeHostEntrypoint, CodeModeHostStub, ConversationClientError, ConversationMaintenance, ConversationObjectClass, ConversationObjectIdentity, ConversationObjectInstance, ConversationObjectNamespace, ConversationObjectOptions, ConversationObjectPorts, ConversationObjectRpc, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, DynamicWorkerCodeExecutorOptions, ExplainedRecovery, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassFailure, MaintenancePassReport, ObligationsScanned, ObservePageRequest, ObservedPage, RetryExecuted, SettlementReached, SubmitRequest, SubmitSucceeded, UnknownResolutionRecorded, VerifiedIntegrity, boundHostDiagnostic, cloudflareWakeSchedulerLayer, conversationNamespaceFromEnv, conversationNamespaceLayer, conversationPortTransportLayer, decodeAbortCommand, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeApprovalDecisionCommand, decodeHostResponse, decodeObligationThresholds, decodeObservePageRequest, decodeReceipt, decodeRetryCommand, decodeSubmitRequest, decodeUnknownResolutionCommand, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeAdminResponse, encodeApprovalDecisionCommand, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeConversationObjectClass };
+export { AbortRecorded, AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, AdmissionLimitExceeded, ApprovalRecorded, AwaitProgressRequest, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CancelProgressRequest, ClientAbortFailure, ClientApprovalFailure, ClientAwaitFailure, ClientObserveFailure, ClientProgressFailure, ClientSubmitFailure, ClientUnknownFailure, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareBindingSource, CloudflareBindingSourceContext, CloudflareConversationClient, CloudflareDurableRuntime, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflareDurableRuntimeInitializationError, CloudflareDurableRuntimeOptions, CloudflareDurableRuntimeServices, CloudflarePlatformConfigError, CodeModeHostEntrypoint, CodeModeHostStub, ConversationClientError, ConversationMaintenance, ConversationMaintenanceFailpoint, ConversationMaintenanceFailpointHandler, ConversationMaintenanceFailpointLocation, ConversationObjectClass, ConversationObjectIdentity, ConversationObjectInstance, ConversationObjectNamespace, ConversationObjectOptions, ConversationObjectPorts, ConversationObjectRpc, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, DynamicWorkerCodeExecutorOptions, ExplainedRecovery, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassFailure, MaintenancePassReport, ObligationsScanned, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, ProgressWaitRegistry, RetryExecuted, SettlementReached, SubmitRequest, SubmitSucceeded, UnknownResolutionRecorded, VerifiedIntegrity, boundHostDiagnostic, cloudflareWakeSchedulerLayer, conversationNamespaceFromEnv, conversationNamespaceLayer, conversationPortTransportLayer, decodeAbortCommand, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObligationThresholds, decodeObservePageRequest, decodeReceipt, decodeRetryCommand, decodeSubmitRequest, decodeUnknownResolutionCommand, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeAdminResponse, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeConversationObjectClass };
 //# sourceMappingURL=index.d.mts.map