fix(core): buffer session-stream chunks even when handlers exist

Persistent listeners registered via `session.in.on(...)` (e.g. chat.agent's
`stopInput.on` for the stop signal) must not 'consume' chunks. They filter
by `kind` and ignore non-matching chunks, so previously `#dispatch` was
silently dropping any chunk that arrived before a once-waiter had registered.

This race surfaced on test cloud (network round-trip > sync subscribe-time)
but not locally (zero-latency). Symptom: chat.agent's first user message
landed in S2 before `messagesInput.waitWithIdleTimeout` registered its
waiter, the tail received it, `#dispatch` saw the `stopInput` handler and
returned without buffering, the message was gone, the waitWithIdleTimeout
fell through to a durable waitpoint, and the race-check skipped seq 0
(since the tail's onPart had advanced `lastSeqNum` to 0).

Fix: when no once-waiter exists, invoke handlers AND buffer the chunk.
Handlers observe; they don't consume.

Author: ericallam

packages/core/src/v3/sessionStreams/manager.ts

@@ -297,11 +297,13 @@ export class StandardSessionStreamManager implements SessionStreamManager {
       return;
     }
 
-    const handlers = this.handlers.get(key);
-    if (handlers && handlers.size > 0) {
-      this.#invokeHandlers(key, data);
-      return;
-    }
+    // Persistent handlers (e.g. `stopInput.on(...)`) get a copy of the chunk,
+    // but they don't "consume" it — handlers usually filter by `kind` and
+    // ignore chunks they don't care about. Buffer the chunk regardless so a
+    // subsequent `once()` (e.g. `messagesInput.waitWithIdleTimeout` in
+    // chat.agent's preload) can still pick up the same chunk that arrived
+    // before its waiter was registered.
+    this.#invokeHandlers(key, data);
 
     let buffered = this.buffer.get(key);
     if (!buffered) {