Struct TranscriptBatchPolicy 

pub struct TranscriptBatchPolicy {
    pub max_batch_events: NonZeroUsize,
    pub max_hold: Duration,
}

The transcript drain’s flush policy: how many queued events one durable commit may carry, and how long the drain may wait to fill that batch.

There is no default, deliberately

Both values are a deployment trade between store cost and transcript latency, so neither is invented here: crate::config::ObservabilityConfig carries them as Options with no default and the boot path refuses to build a publisher without them (the websocket.cluster_broadcast_capacity pattern). A server whose operator has not ruled on them does not start, and says which keys are missing.

Durability contract

Unchanged for the caller of ActivityEventPublisher::publish / ActivityEventPublisher::publish_all: those return only after the events are durably committed, and an event that has been acked as persisted (a returned store_seq) is exactly as durable as before.

What max_hold extends is the window in which an event sits in the server’s IN-MEMORY transcript queue before the drain commits it. That window already existed and is already lossy: the observability tap hands events to a bounded in-process channel, and everything queued there is lost if the server process dies. max_hold lengthens that pre-existing window by at most its own value, and max_batch_events bounds how many events can be waiting in it beyond what the channel already held. Nothing that was durable becomes non-durable; a strictly bounded amount of not-yet-durable transcript stays not-yet-durable for strictly bounded longer.

That trade is acceptable HERE and would not be elsewhere, because the O keyspace is observability, never replay authority: workflow correctness lives on the E-stream, whose append path is untouched by this policy. Losing the last few hundred milliseconds of an agent’s transcript to a kill-9 costs transcript, never a workflow decision — which is the same reason the drain already logs and drops an event the store refuses instead of failing the activity. An operator who wants the old timing sets max_hold_ms = 0: the drain then commits whatever is already queued the moment it can, coalescing only what genuinely arrived together, with no added window at all.

Fields

max_batch_events: NonZeroUsize

Maximum events in one durable commit (observability.max_batch_events).

max_hold: Duration

Maximum time the drain waits for a partial batch to fill (observability.max_batch_hold_ms). Zero means “never wait”.

Implementations

impl TranscriptBatchPolicy

pub const UNBATCHED: Self

The IDENTITY policy: one event per durable commit, never held.

This is the pre-batching behaviour, and the only policy that assumes nothing about a deployment — which is exactly why it is the fallback for the embedder/test state constructors that bypass config validation and cannot refuse to build, and the policy under which the single-event sequencing tests run. A config-driven server never reaches it: it states its own policy or it does not start.

Trait Implementations

impl Clone for TranscriptBatchPolicy

fn clone(&self) -> TranscriptBatchPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for TranscriptBatchPolicy

impl Debug for TranscriptBatchPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for TranscriptBatchPolicy

impl PartialEq for TranscriptBatchPolicy

fn eq(&self, other: &TranscriptBatchPolicy) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for TranscriptBatchPolicy