@moltzap/client 2026.802.0 → 2026.804.0

package/dist/channel-core.js

@@ -1,23 +1,12 @@
 /**
- * Shared message-enrichment helper for MoltZap channel adapters.
+ * Channel core: serialized inbound turn delivery over a MoltZapService.
+ * Owns the inbound queue, same-conversation coalescing, the interceptor
+ * gate, the per-turn timeout, and channel teardown. Enriched adapter delivery
+ * uses channel-core-enrichment.ts; raw daemon delivery receives the coalesced
+ * Message batch without reading or committing presentation context.
  */
-import { Cause, Chunk, Data, Deferred, Duration, Effect, Fiber, Match, Option, Queue, } from "effect";
-import { BoundedMap } from "./bounded-map.js";
-import { DEFAULT_DISPATCH_LEASE_TIMEOUT_MS, } from "@moltzap/protocol/message/dispatch";
+import { Cause, Chunk, Duration, Effect, Fiber, Option, Queue } from "effect";
 import { enrichChannelMessage } from "./channel-core-enrichment.js";
-class DispatchAdmissionTimedOut extends Data.TaggedError("DispatchAdmissionTimedOut") {
-    get message() {
-        return `dispatch request timed out after ${this.timeoutMs}ms`;
-    }
-}
-class DispatchLeaseExpired extends Data.TaggedError("DispatchLeaseExpired") {
-    get message() {
-        return `dispatch lease expired after ${this.timeoutMs}ms`;
-    }
-}
-const DEFAULT_DISPATCH_ADMISSION_TIMEOUT_MS = 30_000;
-const DISPATCH_RELEASE_RING_CAPACITY = 256;
-const DISPATCH_RELEASE_RING_SOFT_TTL_MS = 30_000;
 function errorSummary(err) {
     if (err instanceof Error) {
         return {
@@ -30,8 +19,8 @@ function errorSummary(err) {
         errorValue: String(err),
     };
 }
-function effectLogInfo(message, annotations) {
-    return Effect.logInfo(message).pipe(Effect.annotateLogs(annotations));
+function effectLogDebug(message, annotations) {
+    return Effect.logDebug(message).pipe(Effect.annotateLogs(annotations));
 }
 function effectLogWarning(message, annotations) {
     return Effect.logWarning(message).pipe(Effect.annotateLogs(annotations));
@@ -43,10 +32,15 @@ function runBackgroundLog(effect) {
     Effect.runFork(effect);
 }
 /**
- * Wraps a `MoltZapService` with message enrichment, dispatch-chain ordering,
- * and a send helper. One core per service — `getContextEntries()` is
- * side-effectful (advances per-conversation markers), so a second core
- * would consume entries the first expected.
+ * Wraps a `MoltZapService` with one-turn-at-a-time inbound delivery and a send
+ * helper. Adapter handlers receive enriched messages. A daemon handler may
+ * instead receive the admitted coalesced raw Message batch. One core per
+ * service — `getContextEntries()` is side-effectful (advances
+ * per-conversation markers), so a second core would consume entries the first
+ * expected.
+ *
+ * Turn-taking is entirely endpoint-local: the server delivers every message
+ * it accepts, and this core decides when the runtime sees them.
  *
  * Inbound path from wire bytes to user handler:.
  *
@@ -56,99 +50,86 @@ function runBackgroundLog(effect) {
  *   participant ws as MoltZapAgentClient
  *   participant svc as MoltZapService
  *   participant core as MoltZapChannelCore
- *   participant handler as InboundHandler
+ *   participant raw as RawInboundHandler
+ *   participant enriched as InboundHandler
  *
  *   server->>ws: agent/message/received notification
  *   ws->>svc: subscribers.dispatch — fanout(message)
  *   svc->>core: message listener
- *   Note over core: dedup via recordMessageIdIfNew; Queue.unsafeOffer(inboundQueue, work)
- *   Note over core: messages observed without an inbound handler are transiently dropped; consumer fiber uses Queue.take and takeDispatchCandidate prefers parked[convId]
- *   core->>server: agent/dispatch/request — dispatchAdmission
- *   server-->>core: ack {leaseId, dispatchId}
- *   Note over server,core: ack/release race absorbed via pendingDispatchesByLease (Deferred) and pendingReleasesByLease (ring 256, soft-TTL 30s)
- *   server->>ws: agent/dispatch/released notification
- *   ws->>core: recordDispatchRelease — settles Deferred or buffers
- *   alt verdict deny
- *     Note over core: log + drop
- *   else verdict hold
- *     Note over core: parkDispatchWork — front of parked[convId]
- *   else verdict grant
- *     Note over core: takeCoalescedConversationMessages; drains same-conv from queue + parked
- *     Note over core: dispatchWithLease; lease scoped to ConversationId; enrichMessage — sender name, conversation, context entries
- *     core->>handler: inboundHandler(enriched)
- *     handler-->>core: Effect.void
- *     Note over core: handler exceeds leaseTimeoutMs (90s) → DispatchLeaseExpired
+ *   Note over core: dedup via recordMessageIdIfNew, drop when stopped or no handler is installed, then Queue.unsafeOffer(inboundQueue, message)
+ *   Note over core: consumer fiber — Queue.take
+ *   Note over core: takeCoalescedConversationMessages drains same-conv backlog into one turn
+ *   alt raw daemon handler
+ *     Note over core: inboundInterceptor — deliver or drop this batch
+ *     core->>raw: rawInboundHandler(messages)
+ *     raw-->>core: Effect.void
+ *   else enriched adapter handler
+ *     Note over core: enrichMessage — sender name, conversation, context entries
+ *     Note over core: inboundInterceptor — deliver or drop this turn
+ *     core->>enriched: inboundHandler(enriched)
+ *     enriched-->>core: Effect.void
+ *     Note over core: completed handler commits presentation context
  *   end
+ *   Note over core: handler exceeds turnTimeoutMs — turn abandoned, drain continues
  * ```
  *
- * Parking semantics: `hold` re-enters at `parked[convId]` FRONT.
- * `takeDispatchCandidate` prefers the parked queue for the next pull
- * so backpressure within one conversation does not starve others.
+ * The single consumer fiber awaits the handler inline, so at most one turn
+ * runs at a time and messages that arrive mid-turn wait in the queue.
  */
 export class MoltZapChannelCore {
     service;
-    dispatchAdmissionTimeoutMs;
+    turnTimeoutMs;
+    inboundInterceptor;
     connected = false;
-    inboundHandlerRegistration = null;
-    /**
-     * Dispatch authority is keyed by conversation so work performed through
-     * the core for another conversation cannot inherit the active handler's
-     * lease. The single consumer prevents overlapping writes for the same
-     * conversation while set/restore cleanup is active.
-     */
-    leaseIdsInFlightByConversation = new Map();
-    /**
-     * Per-lease parking Deferreds for dispatches awaiting their
-     * `dispatchRelease` verdict. Settled by the `dispatchRelease` event
-     * handler when a matching frame arrives.
-     */
-    pendingDispatchesByLease = new Map();
-    /**
-     * Ring buffer of `dispatchRelease` frames that arrived before the
-     * recipient registered its parking Deferred (release-then-ack
-     * race). `BoundedMap` refreshes insertion order when a lease is set
-     * again and evicts the oldest entry at capacity. Soft-TTL eviction at
-     * `DISPATCH_RELEASE_RING_SOFT_TTL_MS` keeps a release without a matching
-     * ack from retaining memory.
-     */
-    pendingReleasesByLease = new BoundedMap(DISPATCH_RELEASE_RING_CAPACITY);
-    parkedByConversation = new Map();
+    // Terminal stop: disconnect() interrupts the sole consumer fiber and it is
+    // never restarted, while the service deliberately keeps message listeners
+    // registered across close()/connect() cycles. Without this flag a
+    // reconnected service would keep offering inbound messages into a queue
+    // nothing drains — unbounded growth and silent non-delivery. Stopped means
+    // stopped: inbound observed after disconnect() is dropped at the listener.
+    stopped = false;
+    inboundHandler = null;
     /**
      * Inbound messages with an installed handler enqueue synchronously; a single
-     * forked consumer fiber serialises delivery in arrival order.
+     * forked consumer fiber serialises delivery so handlers execute
+     * one-at-a-time in arrival order.
      */
     inboundQueue = Effect.runSync(Queue.unbounded());
     consumerFiber;
     disconnectHandlers = [];
     constructor(opts) {
         this.service = opts.service;
-        this.dispatchAdmissionTimeoutMs =
-            opts.dispatchAdmissionTimeoutMs ?? DEFAULT_DISPATCH_ADMISSION_TIMEOUT_MS;
+        if (opts.turnTimeoutMs !== undefined) {
+            this.turnTimeoutMs = opts.turnTimeoutMs;
+        }
+        if (opts.inboundInterceptor !== undefined) {
+            this.inboundInterceptor = opts.inboundInterceptor;
+        }
         this.registerMessageListener();
         this.consumerFiber = this.startConsumerFiber();
         this.registerConnectionListeners();
-        this.registerDispatchReleaseListener();
     }
     registerMessageListener() {
         this.service.on("message", ({ message }) => {
-            if (this.inboundHandlerRegistration === null) {
+            // A core with no handler — a daemon that owns the connection without
+            // running a turn loop — observes messages it will never deliver.
+            // Dropping here keeps the queue from holding work nothing consumes, and
+            // makes the pre-registration window a definite drop rather than a race
+            // between the consumer fiber and the embedder's onInbound call.
+            if (this.stopped || this.inboundHandler === null) {
                 return;
             }
-            Queue.unsafeOffer(this.inboundQueue, {
-                message,
-                attempt: 0,
-                receivedAtMs: Date.now(),
-            });
+            Queue.unsafeOffer(this.inboundQueue, message);
         });
     }
     startConsumerFiber() {
-        const consumer = Effect.forever(Queue.take(this.inboundQueue).pipe(Effect.flatMap((work) => this.dispatchInboundWork(work).pipe(Effect.catchAllCause((cause) => this.logInboundFailure(work, cause))))));
+        const consumer = Effect.forever(Queue.take(this.inboundQueue).pipe(Effect.flatMap((message) => this.runInboundTurn(message).pipe(Effect.catchAllCause((cause) => this.logInboundFailure(message, cause))))));
         return Effect.runFork(consumer);
     }
-    logInboundFailure(work, cause) {
+    logInboundFailure(message, cause) {
         return effectLogError("MoltZapChannelCore: inbound handler failed", {
-            messageId: work.message.id,
-            conversationId: work.message.conversationId,
+            messageId: message.id,
+            conversationId: message.conversationId,
             causePretty: Cause.pretty(cause),
             ...errorSummary(Cause.squash(cause)),
         });
@@ -159,76 +140,21 @@ export class MoltZapChannelCore {
             this.fanout(this.disconnectHandlers, "disconnect");
         });
     }
-    registerDispatchReleaseListener() {
-        this.service.on("dispatchRelease", (frame) => {
-            this.recordDispatchRelease(frame);
-        });
-    }
-    /**
-     * Record an incoming `dispatchRelease` frame. If a matching
-     * parking Deferred is registered, settle it inline; otherwise
-     * insert into the ring buffer for the future ack-side `consume`.
-     * Soft-TTL evicts buffered entries whose age exceeds
-     * `DISPATCH_RELEASE_RING_SOFT_TTL_MS`; insertion at the hard cap
-     * evicts the oldest entry. Both eviction paths warn-log so operators
-     * can spot release-without-ack adversarial patterns.
-     * @param frame Value supplied to the operation.
-     */
-    recordDispatchRelease(frame) {
-        const parked = this.pendingDispatchesByLease.get(frame.leaseId);
-        if (parked) {
-            this.pendingDispatchesByLease.delete(frame.leaseId);
-            // `Deferred.unsafeDone` is the sync settler — `succeed` returns an
-            // Effect that the caller would have to runFork. The Deferred has
-            // `never` in the failure channel, so unsafeDone with Exit.succeed
-            // is total.
-            Effect.runSync(Deferred.succeed(parked, frame));
-            return;
-        }
-        const nowMs = Date.now();
-        this.evictDispatchReleaseRing(nowMs);
-        const evicted = this.pendingReleasesByLease.set(frame.leaseId, {
-            verdict: frame.verdict,
-            leaseTimeoutMs: frame.leaseTimeoutMs,
-            receivedAtMs: nowMs,
-        });
-        if (evicted !== undefined) {
-            const [evictedLeaseId] = evicted;
-            runBackgroundLog(effectLogWarning("MoltZapChannelCore: dispatchRelease ring buffer evicted oldest entry (capacity reached)", { leaseId: evictedLeaseId }));
-        }
-    }
-    evictDispatchReleaseRing(nowMs) {
-        for (const [leaseId, entry] of this.pendingReleasesByLease) {
-            if (nowMs - entry.receivedAtMs <= DISPATCH_RELEASE_RING_SOFT_TTL_MS) {
-                // BoundedMap iterates oldest-set first, so every subsequent entry is
-                // fresher once this one remains inside the TTL.
-                return;
-            }
-            this.pendingReleasesByLease.delete(leaseId);
-            runBackgroundLog(effectLogWarning("MoltZapChannelCore: dispatchRelease ring buffer evicted stale entry (soft TTL)", { leaseId, ageMs: nowMs - entry.receivedAtMs }));
-        }
-    }
-    consumeDispatchRelease(leaseId) {
-        const entry = this.pendingReleasesByLease.get(leaseId);
-        if (entry === undefined) {
-            return undefined;
-        }
-        this.pendingReleasesByLease.delete(leaseId);
-        return entry;
-    }
     /**
      * Replaces any previous handler.
      * @param handler Handler invoked for matching requests.
-     * @returns An idempotent disposer for this registration generation.
      */
     onInbound(handler) {
-        const registration = { handler };
-        this.inboundHandlerRegistration = registration;
-        return () => {
-            if (this.inboundHandlerRegistration === registration) {
-                this.inboundHandlerRegistration = null;
-            }
-        };
+        this.inboundHandler = { _tag: "enriched", handler };
+    }
+    /**
+     * Replaces any previous handler with a raw coalesced-turn handler. The
+     * admitted batch passes the interceptor and reaches the handler without
+     * enrichment or presentation-context commits.
+     * @param handler Handler invoked for each admitted raw batch.
+     */
+    onRawInbound(handler) {
+        this.inboundHandler = { _tag: "raw", handler };
     }
     onDisconnect(handler) {
         this.disconnectHandlers.push(handler);
@@ -247,13 +173,32 @@ export class MoltZapChannelCore {
         }
     }
     connect() {
+        // A stopped core has no consumer fiber and its listener drops every
+        // inbound message; reporting a successful connect here would hand the
+        // embedder a healthy-looking channel that is permanently deaf. Stopped
+        // is terminal — reconnecting means constructing a new core.
+        if (this.stopped) {
+            return Effect.dieMessage("MoltZapChannelCore.connect called after disconnect; a stopped core cannot be reconnected — construct a new core");
+        }
         return this.service.connect().pipe(Effect.tap(() => Effect.sync(() => {
             this.connected = true;
         })), Effect.asVoid);
     }
+    /**
+     * Tear the channel down, resolving only once the service's own transports
+     * are closed. A scoped owner releases this before its process exits, so
+     * fire-and-forget teardown would leave sockets open past the scope.
+     *
+     * Service shutdown runs concurrently with interrupting the consumer fiber
+     * because an in-flight turn's finalizer can take arbitrarily long. Awaiting
+     * the interrupt first would hold the transports open for exactly as long as
+     * that finalizer runs.
+     * @returns Completion of the channel-owned teardown.
+     */
     disconnect() {
         return Effect.gen(function* () {
             this.connected = false;
+            this.stopped = true;
             // Interrupt the consumer fiber so any queued inbound messages are
             // dropped rather than delivered after the channel is torn down.
             const stopConsumer = Fiber.interrupt(this.consumerFiber);
@@ -273,390 +218,135 @@ export class MoltZapChannelCore {
         return this.connected;
     }
     /**
-     * Reply into a conversation with an explicit dispatch lease when supplied,
-     * otherwise with only the active lease for `conversationId`.
+     * Reply into a conversation.
      * @param conversationId Value supplied to the operation.
      * @param text Text to process.
-     * @param opts Value supplied to the operation.
-     * @param opts.dispatchLeaseId Value supplied to the operation.
      * @returns The send result.
      */
-    sendReply(conversationId, text, opts) {
-        return this.service.send(conversationId, text, {
-            dispatchLeaseId: opts?.dispatchLeaseId ??
-                this.leaseIdsInFlightByConversation.get(conversationId),
-        });
-    }
-    takeDispatchCandidate(incoming) {
-        const conversationId = incoming.message.conversationId;
-        const parked = this.parkedByConversation.get(conversationId);
-        if (!parked || parked.length === 0) {
-            return incoming;
-        }
-        parked.push(incoming);
-        const next = 
-        /* Safe because the surrounding invariant establishes this asserted shape. */ parked.shift();
-        if (parked.length === 0) {
-            this.parkedByConversation.delete(conversationId);
-        }
-        else {
-            this.parkedByConversation.set(conversationId, parked);
-        }
-        return next;
-    }
-    parkDispatchWork(work) {
-        const conversationId = work.message.conversationId;
-        const parked = this.parkedByConversation.get(conversationId) ?? [];
-        parked.unshift({
-            ...work,
-            attempt: work.attempt + 1,
-        });
-        this.parkedByConversation.set(conversationId, parked);
+    sendReply(conversationId, text) {
+        return this.service.send(conversationId, text);
     }
-    /**
-     * Issue `agent/dispatch/request` against the service, await the lease's
-     * `dispatchRelease` verdict, and return the channel-core
-     * `DispatchAdmissionDecision`. Absorbs the ack/release race via
-     * `pendingDispatchesByLease` (Deferred) plus
-     * `pendingReleasesByLease` (refresh-on-set FIFO ring buffer):
-     *   - if release arrives first, the `recordDispatchRelease` event
-     *     handler buffers it; this method consumes the buffered entry
-     *     after the ack returns.
-     *   - if ack arrives first, this method registers a Deferred that
-     *     `recordDispatchRelease` settles when the release frame
-     *     arrives.
-     *
-     * Per-message lease state machine:.
-     *
-     * ```mermaid
-     * stateDiagram-v2
-     *   [*] --> PENDING
-     *   PENDING : agent/dispatch/request sent; server minting lease
-     *   PENDING --> AWAITING_RELEASE : ack returns leaseId
-     *   AWAITING_RELEASE : Deferred registered; or buffered release consumed
-     *   AWAITING_RELEASE --> GRANTED : verdict grant
-     *   AWAITING_RELEASE --> DENIED : verdict deny
-     *   AWAITING_RELEASE --> HELD : verdict hold
-     *   HELD : parkDispatchWork — re-queued at parked[convId] front
-     *   GRANTED : proceed to enrichment
-     *   DENIED : drop message — consumer fiber continues
-     *   GRANTED --> IN_FLIGHT : dispatchWithLease
-     *   IN_FLIGHT : lease keyed by ConversationId; handler executing; lease authorizes one agent/message/send
-     *   IN_FLIGHT --> CONSUMED : handler returns within leaseTimeoutMs; server marks via dispatchLeaseId
-     *   IN_FLIGHT --> EXPIRED : handler exceeds leaseTimeoutMs; DispatchLeaseExpired logged
-     *   CONSUMED --> [*]
-     *   DENIED --> [*]
-     *   EXPIRED --> [*]
-     * ```
-     *
-     * `HELD` stays at the parked-front. Later inbound work for that same
-     * conversation wakes its next dispatch attempt without preventing inbound
-     * work for other conversations from progressing.
-     *
-     * When the service has no `requestDispatch` (test fakes that don't
-     * exercise admission), default-grant.
-     *
-     * On request error or release wait timeout, fail-closed with a
-     * synthetic deny verdict. The lease (if minted server-side) ages
-     * out via the post-grant TTL or LeaseRegistry's
-     * abandon-on-disconnect path; nothing here re-issues.
-     * @param work Value supplied to the operation.
-     * @returns The dispatch admission result.
-     */
-    dispatchAdmission(work) {
-        if (!this.service.requestDispatch) {
-            return Effect.succeed({ _tag: "grant" });
-        }
-        return Effect.suspend(() => 
-        /* Safe because the surrounding invariant establishes this asserted shape. */ this
-            .service.requestDispatch({
-            conversationId: work.message.conversationId,
-            messageId: work.message.id,
-            senderAgentId: work.message.senderId,
-            parts: work.message.parts,
-            attempt: work.attempt,
-            receivedAt: new Date(work.receivedAtMs).toISOString(),
-            pending: this.pendingDispatchSnapshot(work),
-        })).pipe(
-        // Total deadline for the admission round-trip (ack + release).
-        // Hangs in the underlying RPC fall through to the fail-closed
-        // branch below; the request itself does not race the ack/release
-        // timeouts independently.
-        Effect.timeoutFail({
-            duration: Duration.millis(this.dispatchAdmissionTimeoutMs),
-            onTimeout: () => new DispatchAdmissionTimedOut({
-                timeoutMs: this.dispatchAdmissionTimeoutMs,
-            }),
-        }), Effect.flatMap((result) => "outcome" in result
-            ? Effect.succeed(MoltZapChannelCore.holdDecision(result.outcome))
-            : this.awaitDispatchRelease(work, result.leaseId)), Effect.catchAll((err) => Effect.gen(function* () {
-            yield* effectLogWarning("MoltZapChannelCore: dispatch admission failed closed", {
-                messageId: work.message.id,
-                conversationId: work.message.conversationId,
-                attempt: work.attempt,
-                err,
-            });
-            return {
-                _tag: "deny",
-                reason: "dispatch admission unavailable",
-            };
-        })));
-    }
-    /**
-     * Wait for the verdict on `leaseId`. Consumes any buffered
-     * `dispatchRelease` first; otherwise registers a parking Deferred
-     * and bounded-waits for the `recordDispatchRelease` event handler
-     * to settle it. The wait timeout matches today's
-     * `dispatchAdmissionTimeoutMs` (default 30 s).
-     * @param work Value supplied to the operation.
-     * @param leaseId Value supplied to the operation.
-     * @returns The buffered result.
-     */
-    awaitDispatchRelease(work, leaseId) {
+    runInboundTurn(primary) {
         return Effect.gen(function* () {
-            const buffered = this.consumeDispatchRelease(leaseId);
-            if (buffered) {
-                return this.projectVerdict(work, leaseId, buffered.verdict);
+            const messages = yield* this.takeCoalescedConversationMessages(primary);
+            const registered = this.inboundHandler;
+            if (registered === null) {
+                return;
             }
-            const deferred = yield* Deferred.make();
-            this.pendingDispatchesByLease.set(leaseId, deferred);
-            // `ensuring` (not `tap`) guarantees the entry is removed even on
-            // interrupt — without it, a fiber interruption (consumer fiber
-            // teardown on `disconnect`) would orphan the Deferred + leak the
-            // lease entry until process exit.
-            const settled = yield* Deferred.await(deferred).pipe(Effect.timeoutOption(Duration.millis(this.dispatchAdmissionTimeoutMs)), Effect.ensuring(Effect.sync(() => {
-                this.pendingDispatchesByLease.delete(leaseId);
-            })));
-            if (Option.isNone(settled)) {
-                yield* effectLogWarning("MoltZapChannelCore: dispatchRelease wait timed out - fail-closed deny", {
-                    messageId: work.message.id,
-                    conversationId: work.message.conversationId,
-                    leaseId,
-                    timeoutMs: this.dispatchAdmissionTimeoutMs,
-                });
-                return {
-                    _tag: "deny",
-                    reason: "dispatch release wait timed out",
-                };
+            if (registered._tag === "raw") {
+                if (!(yield* this.interceptTurn(messages))) {
+                    return;
+                }
+                yield* this.awaitHandlerTurn(registered.handler, messages, primary);
+                return;
             }
-            return this.projectVerdict(work, leaseId, settled.value.verdict);
-        }.bind(this));
-    }
-    projectVerdict(work, leaseId, verdict) {
-        if (verdict.decision === "grant") {
-            return this.projectGrantVerdict(work, leaseId, verdict);
-        }
-        if (verdict.decision === "deny") {
-            return MoltZapChannelCore.denyDecision(verdict.reason);
-        }
-        return MoltZapChannelCore.holdDecision(verdict.reason);
-    }
-    projectGrantVerdict(work, leaseId, verdict) {
-        runBackgroundLog(effectLogInfo("MoltZapChannelCore: dispatch admission granted", {
-            messageId: work.message.id,
-            conversationId: work.message.conversationId,
-            attempt: work.attempt,
-            leaseId,
-            leaseTimeoutMs: verdict.leaseTimeoutMs,
-            dispatchMessageId: verdict.dispatchMessageId,
-        }));
-        return {
-            _tag: "grant",
-            leaseId: verdict.leaseId ?? leaseId,
-            ...(verdict.leaseTimeoutMs !== undefined
-                ? { leaseTimeoutMs: verdict.leaseTimeoutMs }
-                : {}),
-            ...(verdict.dispatchMessageId
-                ? { dispatchMessageId: verdict.dispatchMessageId }
-                : {}),
-        };
-    }
-    static denyDecision(reason) {
-        return {
-            _tag: "deny",
-            ...(reason !== undefined ? { reason } : {}),
-        };
-    }
-    static holdDecision(reason) {
-        return {
-            _tag: "hold",
-            ...(reason !== undefined ? { reason } : {}),
-        };
-    }
-    dispatchInboundWork(work) {
-        return Effect.gen(function* () {
-            const current = this.takeDispatchCandidate(work);
-            const decision = yield* this.dispatchAdmission(current);
-            yield* this.handleDispatchDecision(current, decision);
-        }.bind(this));
-    }
-    handleDispatchDecision(current, decision) {
-        return Match.value(decision).pipe(Match.tag("grant", (grant) => this.dispatchGrantedWork(current, grant)), Match.tag("deny", (deny) => this.logDeniedDispatch(current, deny)), Match.tag("hold", (hold) => this.holdDispatchWork(current, hold)), Match.exhaustive);
-    }
-    dispatchGrantedWork(current, decision) {
-        return Effect.gen(function* () {
-            const messages = yield* this.messagesForGrantedDispatch(current, decision);
-            if (messages.length === 0) {
-                yield* this.logDispatchTargetUnavailable(current, decision);
+            const { enriched, commitContext } = yield* MoltZapChannelCore.enrichMessage(this.service, messages);
+            if (!(yield* this.interceptTurn(messages))) {
                 return;
             }
-            const primaryMessage = 
-            /* Safe because the surrounding invariant establishes this asserted shape. */ messages[0];
-            yield* this.logDispatchStart(current, primaryMessage, messages, decision);
-            const timedOut = yield* this.runGrantedDispatch(current, primaryMessage, messages, decision);
-            if (!timedOut) {
-                yield* this.logDispatchCompleted(current, primaryMessage, decision);
+            const completed = yield* this.awaitHandlerTurn(registered.handler, enriched, primary);
+            // Context markers advance only for a turn the handler finished. A
+            // dropped or abandoned one leaves its entries for the next turn.
+            if (completed && commitContext) {
+                commitContext();
             }
         }.bind(this));
     }
-    messagesForGrantedDispatch(current, decision) {
-        return this.service.requestDispatch
-            ? this.takeCoalescedConversationMessages(current, decision.dispatchMessageId)
-            : Effect.succeed([current.message]);
-    }
-    runGrantedDispatch(current, primaryMessage, messages, decision) {
-        const dispatch = this.dispatchWithLease(primaryMessage.conversationId, messages, decision.leaseId);
-        const timeoutMs = MoltZapChannelCore.leaseTimeoutMs(decision);
-        if (timeoutMs === undefined) {
-            return dispatch.pipe(Effect.as(false));
+    /**
+     * Consult the interceptor for this turn, if one is installed.
+     * @param messages The coalesced batch, primary first.
+     * @returns Whether the handler runs for this batch.
+     */
+    interceptTurn(messages) {
+        const interceptor = this.inboundInterceptor;
+        if (interceptor === undefined) {
+            return Effect.succeed(true);
         }
-        return dispatch.pipe(Effect.timeoutFail({
-            duration: Duration.millis(timeoutMs),
-            onTimeout: () => new DispatchLeaseExpired({
-                messageId: primaryMessage.id,
-                conversationId: primaryMessage.conversationId,
-                timeoutMs,
-            }),
-        }), Effect.as(false), Effect.catchAll((err) => this.handleDispatchFailure(err, current, decision)));
+        const newest = 
+        /* Safe because a coalesced batch always holds at least its primary. */ messages[messages.length - 1];
+        // Suspended so an interceptor that throws before returning its Effect
+        // becomes a defect this pipeline can fail open on, not one the consumer
+        // fiber catches after the turn is already lost.
+        return Effect.suspend(() => interceptor(newest)).pipe(Effect.flatMap((decision) => this.applyInterceptDecision(newest, decision)), Effect.catchAllCause((cause) => 
+        // Interruption is teardown, not an interceptor bug: re-raise it so a
+        // disconnected channel stops draining instead of delivering the turn.
+        Cause.isInterruptedOnly(cause)
+            ? Effect.failCause(cause)
+            : this.logInterceptorFailure(newest, cause).pipe(Effect.as(true))));
     }
-    dispatchWithLease(conversationId, messages, leaseId) {
-        return Effect.sync(() => {
-            const previous = this.leaseIdsInFlightByConversation.get(conversationId);
-            if (leaseId === undefined) {
-                this.leaseIdsInFlightByConversation.delete(conversationId);
-            }
-            else {
-                this.leaseIdsInFlightByConversation.set(conversationId, leaseId);
-            }
-            return previous;
-        }).pipe(Effect.flatMap((previous) => this.dispatchInboundEffect(messages).pipe(Effect.ensuring(Effect.sync(() => {
-            if (previous === undefined) {
-                this.leaseIdsInFlightByConversation.delete(conversationId);
-            }
-            else {
-                this.leaseIdsInFlightByConversation.set(conversationId, previous);
-            }
-        })))));
-    }
-    static leaseTimeoutMs(decision) {
-        return decision.leaseId
-            ? (decision.leaseTimeoutMs ?? DEFAULT_DISPATCH_LEASE_TIMEOUT_MS)
-            : undefined;
-    }
-    handleDispatchFailure(err, current, decision) {
-        if (err instanceof DispatchLeaseExpired) {
-            return this.logDispatchLeaseExpired(err, current, decision);
+    /**
+     * Apply a verdict, logging the drops at debug so a quiet channel can be
+     * traced back to its gate.
+     * @param newest Message the interceptor judged.
+     * @param decision Verdict for the whole coalesced batch.
+     * @returns Whether the handler runs.
+     */
+    applyInterceptDecision(newest, decision) {
+        if (decision._tag === "deliver") {
+            return Effect.succeed(true);
         }
-        return Effect.fail(err);
-    }
-    holdDispatchWork(current, decision) {
-        return Effect.gen(function* () {
-            yield* effectLogInfo("MoltZapChannelCore: inbound dispatch held", {
-                messageId: current.message.id,
-                conversationId: current.message.conversationId,
-                attempt: current.attempt,
-                reason: decision.reason,
-            });
-            this.parkDispatchWork(current);
-        }.bind(this));
-    }
-    logDispatchTargetUnavailable(current, decision) {
-        return effectLogWarning("MoltZapChannelCore: dispatch admission target unavailable", {
-            messageId: current.message.id,
-            conversationId: current.message.conversationId,
-            attempt: current.attempt,
-            dispatchMessageId: decision.dispatchMessageId,
-        });
-    }
-    logDispatchStart(current, primaryMessage, messages, decision) {
-        return effectLogInfo("MoltZapChannelCore: inbound dispatch starting", {
-            messageId: primaryMessage.id,
-            admittedMessageId: current.message.id,
-            conversationId: current.message.conversationId,
-            attempt: current.attempt,
-            leaseId: decision.leaseId,
-            coalescedMessageCount: messages.length,
-        });
-    }
-    logDispatchLeaseExpired(err, current, decision) {
-        return effectLogWarning("MoltZapChannelCore: inbound dispatch lease expired", {
-            messageId: err.messageId,
-            conversationId: err.conversationId,
-            attempt: current.attempt,
-            leaseId: decision.leaseId,
-            timeoutMs: err.timeoutMs,
-        }).pipe(Effect.as(true));
-    }
-    logDispatchCompleted(current, primaryMessage, decision) {
-        return effectLogInfo("MoltZapChannelCore: inbound dispatch completed", {
-            messageId: primaryMessage.id,
-            admittedMessageId: current.message.id,
-            conversationId: current.message.conversationId,
-            attempt: current.attempt,
-            leaseId: decision.leaseId,
-        });
-    }
-    logDeniedDispatch(current, decision) {
-        return effectLogInfo("MoltZapChannelCore: inbound dispatch denied", {
-            messageId: current.message.id,
-            conversationId: current.message.conversationId,
-            attempt: current.attempt,
-            reason: decision.reason,
+        return effectLogDebug("MoltZapChannelCore: inbound turn dropped by interceptor", {
+            messageId: newest.id,
+            conversationId: newest.conversationId,
+            ...(decision.reason !== undefined ? { reason: decision.reason } : {}),
+        }).pipe(Effect.as(false));
+    }
+    logInterceptorFailure(newest, cause) {
+        return effectLogWarning("MoltZapChannelCore: inbound interceptor failed, delivering anyway", {
+            messageId: newest.id,
+            conversationId: newest.conversationId,
+            causePretty: Cause.pretty(cause),
+            ...errorSummary(Cause.squash(cause)),
         });
     }
-    pendingDispatchSnapshot(active) {
-        const queued = Chunk.toReadonlyArray(Effect.runSync(Queue.takeAll(this.inboundQueue)));
-        for (const work of queued) {
-            Queue.unsafeOffer(this.inboundQueue, work);
+    /**
+     * Await the user handler, bounded by `turnTimeoutMs` when it is set.
+     * @param handler Installed inbound handler.
+     * @param input Value delivered to the selected handler.
+     * @param primary Message that opened this turn.
+     * @returns Whether the handler ran to completion.
+     */
+    awaitHandlerTurn(handler, input, primary) {
+        // The handler is user code returning an Effect — yield it directly so its
+        // typed error channel propagates to the consumer fiber, which logs and
+        // continues. Awaiting it inline preserves arrival-order delivery.
+        const turn = handler(input);
+        const timeoutMs = this.turnTimeoutMs;
+        if (timeoutMs === undefined) {
+            return turn.pipe(Effect.as(true));
         }
-        const parked = [...this.parkedByConversation.values()].flat();
-        return [active, ...parked, ...queued].map((work) => ({
-            messageId: work.message.id,
-            conversationId: work.message.conversationId,
-            senderAgentId: work.message.senderId,
-            createdAt: work.message.createdAt,
-            receivedAt: new Date(work.receivedAtMs).toISOString(),
-            parts: work.message.parts,
-        }));
+        return turn.pipe(Effect.timeoutOption(Duration.millis(timeoutMs)), Effect.tap((finished) => Option.isNone(finished)
+            ? effectLogWarning("MoltZapChannelCore: inbound turn abandoned after timeout", {
+                messageId: primary.id,
+                conversationId: primary.conversationId,
+                timeoutMs,
+            })
+            : Effect.void), Effect.map(Option.isSome));
     }
-    takeCoalescedConversationMessages(work, dispatchMessageId) {
+    /**
+     * Drain every queued message for the primary's conversation into one turn,
+     * leaving other conversations queued in arrival order. Coalescing keeps a
+     * burst in one conversation from costing one turn per message.
+     * @param primary Message that opened this turn.
+     * @returns The messages belonging to this turn, primary first.
+     */
+    takeCoalescedConversationMessages(primary) {
         return Effect.sync(() => {
             const queued = Chunk.toReadonlyArray(Effect.runSync(Queue.takeAll(this.inboundQueue)));
-            const parked = this.parkedByConversation.get(work.message.conversationId);
-            const sameConversation = [work.message];
+            const sameConversation = [primary];
             const remaining = [];
-            if (parked) {
-                sameConversation.push(...parked.map((parkedWork) => parkedWork.message));
-                this.parkedByConversation.delete(work.message.conversationId);
-            }
-            for (const queuedWork of queued) {
-                if (queuedWork.message.conversationId === work.message.conversationId) {
-                    sameConversation.push(queuedWork.message);
+            for (const queuedMessage of queued) {
+                if (queuedMessage.conversationId === primary.conversationId) {
+                    sameConversation.push(queuedMessage);
                 }
                 else {
-                    remaining.push(queuedWork);
+                    remaining.push(queuedMessage);
                 }
             }
-            const startIndex = dispatchMessageId === undefined
-                ? 0
-                : sameConversation.findIndex((message) => message.id === dispatchMessageId);
-            for (const remainingWork of remaining) {
-                Queue.unsafeOffer(this.inboundQueue, remainingWork);
+            for (const remainingMessage of remaining) {
+                Queue.unsafeOffer(this.inboundQueue, remainingMessage);
             }
-            if (startIndex < 0) {
-                return [];
-            }
-            return sameConversation.slice(startIndex);
+            return sameConversation;
         });
     }
     /**
@@ -664,30 +354,10 @@ export class MoltZapChannelCore {
      * `resolveAgentName` throws (e.g. Service not yet connected).
      * @param service Value supplied to the operation.
      * @param messageOrMessages Value supplied to the operation.
-     * @returns The leased result.
+     * @returns The enriched message and its context-commit callback.
      */
     static enrichMessage(service, messageOrMessages) {
         return enrichChannelMessage(service, messageOrMessages);
     }
-    dispatchInboundEffect(messages) {
-        return Effect.gen(function* () {
-            const registration = this.inboundHandlerRegistration;
-            if (registration === null) {
-                return;
-            }
-            const { enriched, commitContext } = yield* MoltZapChannelCore.enrichMessage(this.service, messages);
-            const leaseId = this.leaseIdsInFlightByConversation.get(enriched.conversationId);
-            const leased = leaseId !== undefined
-                ? { ...enriched, dispatchLeaseId: leaseId }
-                : enriched;
-            // The handler is user code returning an Effect — yield it directly so
-            // its typed error channel propagates to the consumer fiber, which logs
-            // and continues. We await it inline to preserve arrival-order delivery.
-            yield* registration.handler(leased);
-            if (commitContext) {
-                commitContext();
-            }
-        }.bind(this));
-    }
 }
 //# sourceMappingURL=channel-core.js.map