commandmate 0.26.1 → 0.27.0

package/dist/server/src/lib/hooks/sources/opencode/source.js

@@ -49,6 +49,7 @@ const agent_event_types_1 = require("../../../../lib/hooks/agent-event-types");
 const hook_settings_generator_1 = require("../../../../lib/hooks/hook-settings-generator");
 const logger_1 = require("../../../../lib/logger");
 const define_source_1 = require("../define-source");
+const pending_decisions_1 = require("../pending-decisions");
 const client_1 = require("./client");
 const mappers_1 = require("./mappers");
 const payloads_1 = require("./payloads");
@@ -104,6 +105,7 @@ async function decideOpencode(target, decision, verdict) {
             decisionId: decision.id,
             consequence: 'the agent waits indefinitely; nothing else will unblock it',
         });
+        (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, { delivered: false, reason: 'abstained' });
         return;
     }
     const port = (0, ports_1.getAssignedOpencodePort)(target);
@@ -113,6 +115,7 @@ async function decideOpencode(target, decision, verdict) {
             instanceId,
             decisionId: decision.id,
         });
+        (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, { delivered: false, reason: 'no-port' });
         return;
     }
     if (decision.kind === 'question') {
@@ -126,6 +129,10 @@ async function decideOpencode(target, decision, verdict) {
                 decisionId: decision.id,
                 verdict: verdict.kind,
             });
+            (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, {
+                delivered: false,
+                reason: 'question-needs-answer-verdict',
+            });
             return;
         }
         const delivered = await (0, client_1.replyOpencodeQuestion)(port, decision.id, verdict.answers);
@@ -135,11 +142,17 @@ async function decideOpencode(target, decision, verdict) {
             decisionId: decision.id,
             delivered,
         });
+        (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, {
+            delivered,
+            reason: delivered ? 'question-reply' : 'question-reply-failed',
+        });
         return;
     }
     const reply = toOpencodePermissionReply(verdict);
-    if (reply === null)
+    if (reply === null) {
+        (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, { delivered: false, reason: 'no-wire-value' });
         return;
+    }
     const delivered = await (0, client_1.replyOpencodePermission)(port, decision.id, reply, verdict.kind === 'deny' ? verdict.message : undefined);
     logger.info('opencode-permission-replied', {
         worktreeId: target.worktreeId,
@@ -148,6 +161,13 @@ async function decideOpencode(target, decision, verdict) {
         reply,
         delivered,
     });
+    // Issue #1898: the fact the ingest needs in order to decide whether a human
+    // is still blocked. `replyOpencodePermission` answers false for a refused
+    // connection, and a verdict that never arrived leaves the dialog on screen.
+    (0, pending_decisions_1.recordDecisionDelivery)(target, decision.id, {
+        delivered,
+        reason: delivered ? `permission-reply:${reply}` : 'permission-reply-failed',
+    });
 }
 /** Re-read what is waiting on a human (C7). */
 async function listOpencodePending(target) {
@@ -178,6 +198,11 @@ async function listOpencodePending(target) {
  * Note what `busy` includes: a session blocked on an approval reads `busy`
  * (#1758 §5.3.1), because from the server's point of view the turn has not
  * ended. This answers "is the turn over", never "is a human needed".
+ *
+ * The aggregate of the same `GET /session/status` the reconnect reads per
+ * session (#1900). Callers outside this directory hold an instance rather than
+ * a session id, so aggregating is the only answer they can use; the reconnect
+ * needs the detail, and both go through one reader in `./client`.
  */
 async function probeOpencodeActivity(target) {
     const port = (0, ports_1.getAssignedOpencodePort)(target);
@@ -234,6 +259,24 @@ exports.opencodeAgentEventSource = (0, define_source_1.definePullEventSource)({
         supportedEvents: OPENCODE_SUPPORTED_EVENTS,
         configScope: 'none',
         decisionTimeoutSeconds: null,
+        // Issue #1924, §4 D3. Not hooks at all: CommandMate holds the SSE stream and
+        // adjudicates itself, so there is no hook answer to forecast a dialog from.
+        permissionHookPredictsDialog: false,
+        sessionStartMayArriveLate: false,
+        // `permission.replied` arrives on the same stream and is a positive
+        // statement that the dialog is gone (#1898). The only source that can say so.
+        permissionReplyReleasesPrompt: true,
+        // `per_...` — the id in the reply URL, which is the same id the frame
+        // carries (#1899). Real identity, so this source does not need the time
+        // window that loses the `stop` of a short turn.
+        eventIdentity: 'permission-id',
+        // pull: the stream can drop, and `GET /session/status` is how a reconnect
+        // finds out whether the conversation is still working (#1900). Read by
+        // `./subscription`, which re-arms a `busy` session and synthesises the
+        // `stop` of one that finished off-stream; flipping this to `'none'` puts
+        // both back to the pre-#1900 behaviour, which is what the mutation case in
+        // `tests/unit/hooks/sources/opencode-resilience-1900.test.ts` asserts.
+        resync: 'session-status-poll',
     },
     // C4. Predicates, not a name table: see ./mappers.
     mappers: mappers_1.OPENCODE_MAPPERS,
@@ -244,10 +287,18 @@ exports.opencodeAgentEventSource = (0, define_source_1.definePullEventSource)({
     // Issue #1783: nor `properties.info.model.*`, so the spec takes the reader
     // instead of a key list. See {@link frameModel} for the two spellings.
     extractModel: mappers_1.frameModel,
+    // Issue #1899: the extraction half of `eventIdentity: 'permission-id'`. The
+    // capability above says which id de-duplication uses; this is what reads it,
+    // and the two must be changed together — declaring the capability without
+    // this puts every frame back on the 3-second window.
+    extractEventIdentity: mappers_1.opencodeEventIdentity,
     parsePermissionRequest: payloads_1.parseOpencodePermissionRequest,
     parseQuestion: payloads_1.parseOpencodeQuestion,
-    // Self-reference resolves at call time, which is after this const is bound.
-    subscribe: (target, onEvent) => (0, subscription_1.openOpencodeSubscription)(target, onEvent, (raw) => exports.opencodeAgentEventSource.normalizeEvent(raw)),
+    // Self-reference resolves at call time, which is after this const is bound —
+    // which is also how the reconnect loop gets to read a capability declared in
+    // the same object literal it is declared in (#1900). It is handed across
+    // rather than imported because `./subscription` is imported *by* this module.
+    subscribe: (target, onEvent) => (0, subscription_1.openOpencodeSubscription)(target, onEvent, (raw) => exports.opencodeAgentEventSource.normalizeEvent(raw), { resync: exports.opencodeAgentEventSource.capabilities.resync }),
     decide: decideOpencode,
     listPending: listOpencodePending,
     probeActivity: probeOpencodeActivity,

package/dist/server/src/lib/hooks/sources/opencode/subscription.js

@@ -13,10 +13,18 @@
  * - **Reconnect, and re-read what was missed.** Durable replay does not work on
  *   1.18.3: `GET /api/session/:id/event?after=<seq>` returns zero bytes (#1758
  *   §5.2.2). So a reconnect cannot ask "what did I miss"; it re-reads *state*
- *   instead, from `GET /permission` and `GET /question`, which is what makes a
- *   dropped approval recoverable rather than lost forever. A missed
- *   `session.idle` is not recoverable and is not pretended to be — `wait` falls
+ *   instead, from `GET /permission`, `GET /question` and — since Issue #1900 —
+ *   `GET /session/status`. The first two make a dropped approval recoverable
+ *   rather than lost forever. The third makes a dropped *turn boundary*
+ *   recoverable too: a session the server still calls busy is re-armed, and one
+ *   it calls idle that was mid-turn when the stream died is the `stop` that
+ *   never arrived. What is still not recoverable is a boundary the server has
+ *   stopped reporting either way, and that is not pretended to be — `wait` falls
  *   back to the scraper, which is the pre-#1763 behaviour.
+ * - **Not believe a port that changed hands.** The server is loopback and
+ *   unauthenticated, so the identity check in {@link degradeToScraper}'s caller
+ *   is what stands between "the pane owns this port" and a squatter closing a
+ *   `wait` with one frame (§4 D3, DR4-004).
  * - **Not report a turn twice.** See `./turn-gate`.
  * - **Not throw on an unknown frame.** `server.heartbeat` arrives every ten
  *   seconds and is not in the server's own OpenAPI `Event` union (#1758 D5), so
@@ -39,12 +47,13 @@
  * @module lib/hooks/sources/opencode/subscription
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPENCODE_RECONNECT_BACKOFF_MS = exports.OPENCODE_HEARTBEAT_TIMEOUT_MS = void 0;
+exports.MAX_RESYNCED_DECISIONS = exports.OPENCODE_RECONNECT_BACKOFF_MS = exports.OPENCODE_HEARTBEAT_TIMEOUT_MS = void 0;
 exports.isOpencodeSubscribed = isOpencodeSubscribed;
 exports.getOpencodeLiveness = getOpencodeLiveness;
 exports.openOpencodeSubscription = openOpencodeSubscription;
 exports.closeOpencodeSubscription = closeOpencodeSubscription;
 exports.resetOpencodeSubscriptions = resetOpencodeSubscriptions;
+exports.waitUnlessAborted = waitUnlessAborted;
 const logger_1 = require("../../../../lib/logger");
 const auto_yes_state_1 = require("../../../../lib/auto-yes-state");
 const event_mapper_1 = require("../event-mapper");
@@ -69,6 +78,14 @@ exports.OPENCODE_RECONNECT_BACKOFF_MS = [
 ];
 /** Cap on remembered decision ids, so a long session cannot grow the set. */
 const MAX_SEEN_DECISIONS = 256;
+/**
+ * Cap on approvals and questions replayed by one re-sync (§4 D3, DR4-009).
+ *
+ * The same number and the same reason as `MAX_RECHECKED_DECISIONS`: the list
+ * comes off a server CommandMate did not start, and a bounded pass that reports
+ * its overflow beats an unbounded one that does not.
+ */
+exports.MAX_RESYNCED_DECISIONS = 50;
 const subscriptions = (globalThis.__opencodeSubscriptions ??= new Map());
 function keyOf(target) {
     return (0, auto_yes_state_1.buildCompositeKey)(target.worktreeId, target.cliToolId, target.instanceId);
@@ -106,14 +123,14 @@ function inertSubscription() {
  * @param onEvent - Receives normalised events, gated by {@link TurnGate}
  * @param normalize - The source's own `normalizeEvent`, passed in rather than
  *   imported so this module does not depend on the module that depends on it
- * @param port - Overrides the recorded assignment. For tests
+ * @param options - See {@link OpencodeSubscriptionOptions}
  */
-async function openOpencodeSubscription(target, onEvent, normalize, port) {
+async function openOpencodeSubscription(target, onEvent, normalize, options = {}) {
     const key = keyOf(target);
     const existing = subscriptions.get(key);
     if (existing)
         return handleFor(existing);
-    const resolvedPort = port ?? (0, ports_1.getAssignedOpencodePort)(target);
+    const resolvedPort = options.port ?? (0, ports_1.getAssignedOpencodePort)(target);
     if (resolvedPort === null) {
         // No port was assigned: structured events are off, allocation failed, or
         // this pane predates the feature. All three mean "the scraper is in charge",
@@ -131,8 +148,11 @@ async function openOpencodeSubscription(target, onEvent, normalize, port) {
         onEvent,
         normalize,
         gate: (0, turn_gate_1.createTurnGate)(),
+        resync: options.resync ?? 'none',
         seenDecisions: new Set(),
         streamController: new AbortController(),
+        lifetimeController: new AbortController(),
+        serverVersion: null,
         liveness: { state: 'unknown' },
         closed: false,
         watchdog: null,
@@ -167,6 +187,8 @@ async function closeOpencodeSubscription(target) {
     state.closed = true;
     clearWatchdog(state);
     state.streamController.abort();
+    // Issue #1900: the only signal a backoff is listening to.
+    state.lifetimeController.abort();
     subscriptions.delete(key);
     logger.info('opencode-subscription-closed', {
         worktreeId: target.worktreeId,
@@ -180,6 +202,7 @@ function resetOpencodeSubscriptions() {
         state.closed = true;
         clearWatchdog(state);
         state.streamController.abort();
+        state.lifetimeController.abort();
     }
     subscriptions.clear();
 }
@@ -212,15 +235,36 @@ function armWatchdog(state) {
     timer.unref?.();
     state.watchdog = timer;
 }
-/** Sleep, unless the subscription is torn down first. */
-function delay(ms, signal) {
+/**
+ * Sleep, unless the subscription is torn down first.
+ *
+ * The already-aborted check and the listener removal are both load-bearing
+ * (Issue #1900). Without the first, a signal that aborted before the call — the
+ * ordinary case, because the abort is what ended the read — waits out the full
+ * delay with nothing able to cut it short. Without the second, every reconnect
+ * leaves a listener on a signal that lives as long as the session, and a pane
+ * that reconnects a dozen times collects a `MaxListenersExceededWarning`.
+ *
+ * Exported as a test seam: both properties are invisible from outside the loop
+ * — a backoff that is not cut short still ends, it just ends late — so the only
+ * way to pin them without a wall-clock assertion is to drive this directly.
+ */
+function waitUnlessAborted(ms, signal) {
     return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        timer.unref?.();
-        signal.addEventListener('abort', () => {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        const onAbort = () => {
             clearTimeout(timer);
             resolve();
-        }, { once: true });
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        timer.unref?.();
     });
 }
 function backoffFor(attempt) {
@@ -233,6 +277,21 @@ function backoffFor(attempt) {
  * Runs until `close()`. Every ending — a clean EOF, an aborted read, a refused
  * connection — is the same thing to this function: reconnect after a backoff,
  * having first re-read the state that could not be replayed.
+ *
+ * ## The order the reconnect does things in (Issue #1900)
+ *
+ * 1. **Ask who is on the port.** `/global/health` has to answer, and answer with
+ *    the same `version` as the first time. §4 D3 (DR4-004) makes this a
+ *    precondition of trusting the stream at all: the port is loopback and
+ *    unauthenticated, so a different process squatting on it could otherwise
+ *    close a `wait` with one `session.idle` frame — or with a single
+ *    `{"ses_x":{"type":"idle"}}` reply to step 3.
+ * 2. **Open the stream, then re-read.** The re-read used to run first, which
+ *    left a window: an approval raised between `GET /permission` and the `/event`
+ *    subscription appeared on neither, and stayed invisible until the *next*
+ *    reconnect. Opening first makes the window an overlap instead — a duplicate
+ *    the `seenDecisions` set collapses.
+ * 3. **Find out whether the turn survived.** See {@link recoverTurnState}.
  */
 async function runStream(state) {
     let attempt = 0;
@@ -240,16 +299,33 @@ async function runStream(state) {
         state.streamController = new AbortController();
         // A reconnect is a new arming window: whatever was mid-turn when the
         // connection dropped, its `session.status(busy)` was on the old stream, and
-        // an idle that arrives without one must not resolve a `wait`.
+        // an idle that arrives without one must not resolve a `wait`. What *was*
+        // armed is carried into `recoverTurnState`, which is the half of the answer
+        // this reset used to throw away.
+        const armedBefore = state.gate.armedSessions();
         state.gate.reset();
         let reason = 'stream-ended';
         try {
-            await resyncPending(state);
-            armWatchdog(state);
-            for await (const frame of (0, client_1.readOpencodeEventStream)(state.port, state.streamController.signal)) {
-                attempt = 0;
+            const identity = await verifyServerIdentity(state);
+            if (state.closed)
+                break;
+            if (identity === 'changed')
+                return;
+            if (identity === 'unreachable') {
+                reason = 'health-unreachable';
+            }
+            else {
+                const frames = await (0, client_1.openOpencodeEventStream)(state.port, state.streamController.signal);
+                state.liveness = { state: 'live', lastHeartbeatAt: Date.now() };
                 armWatchdog(state);
-                handleFrame(state, frame);
+                await resyncPending(state);
+                await recoverTurnState(state, armedBefore);
+                attempt = 0;
+                for await (const frame of frames) {
+                    attempt = 0;
+                    armWatchdog(state);
+                    handleFrame(state, frame);
+                }
             }
         }
         catch (error) {
@@ -268,18 +344,84 @@ async function runStream(state) {
             reason,
             attempt,
         });
-        await delay(backoffFor(attempt), state.streamController.signal);
+        await waitUnlessAborted(backoffFor(attempt), state.lifetimeController.signal);
         attempt += 1;
     }
 }
+/**
+ * Health-before-trust (Issue #1900, §4 D3 DR4-004 / §13.2 S5).
+ *
+ * The first successful probe records the `version`; every later one is compared
+ * against it. Equal — or unknowable, because the field is missing — means carry
+ * on. Different means the process that owned this port is gone and somebody else
+ * has it, at which point nothing on the port may be believed, including the
+ * `/session/status` answer {@link recoverTurnState} would otherwise turn into a
+ * `stop`.
+ *
+ * Anything that is merely *not answering* is a reconnect, not a betrayal: the
+ * caller falls through to the ordinary backoff.
+ */
+async function verifyServerIdentity(state) {
+    const outcome = await (0, client_1.probeOpencodeHealth)(state.port);
+    if (outcome.kind !== 'healthy') {
+        logger.info('opencode-subscription-health-unavailable', {
+            worktreeId: state.target.worktreeId,
+            instanceId: state.target.instanceId ?? state.target.cliToolId,
+            port: state.port,
+            outcome: outcome.kind,
+            status: outcome.kind === 'rejected' ? outcome.status : undefined,
+        });
+        return 'unreachable';
+    }
+    const version = outcome.health.version;
+    if (state.serverVersion === null || version === null) {
+        state.serverVersion ??= version;
+        return 'same';
+    }
+    if (version === state.serverVersion)
+        return 'same';
+    degradeToScraper(state, version);
+    return 'changed';
+}
+/**
+ * Stop watching a port that is no longer this instance's, and say so.
+ *
+ * Not a close in the ordinary sense — the pane may still be alive — so the
+ * subscription is dropped rather than the session. Everything above falls back
+ * to the screen scraper, which is the pre-#1763 behaviour and the only source
+ * left that is reading the pane rather than the port.
+ */
+function degradeToScraper(state, observedVersion) {
+    logger.warn('opencode-subscription-port-identity-changed', {
+        worktreeId: state.target.worktreeId,
+        instanceId: state.target.instanceId ?? state.target.cliToolId,
+        port: state.port,
+        reason: 'port_identity_changed',
+        expectedVersion: state.serverVersion,
+        observedVersion,
+    });
+    state.closed = true;
+    clearWatchdog(state);
+    state.streamController.abort();
+    state.lifetimeController.abort();
+    state.liveness = { state: 'lost', since: Date.now(), reason: 'port_identity_changed' };
+    subscriptions.delete(state.key);
+}
 /**
  * Re-read what is waiting on a human and announce anything not seen yet (C7).
  *
- * The only recovery opencode offers. An approval raised while CommandMate was
- * disconnected is still pending on the server, so re-reading it restores both
- * the "a human is blocked" state and Auto-Yes's chance to adjudicate it — which
- * matters more here than anywhere else, because an unanswered opencode approval
- * waits forever (#1758 §5.5.3).
+ * The only recovery opencode offers for a *decision*. An approval raised while
+ * CommandMate was disconnected is still pending on the server, so re-reading it
+ * restores both the "a human is blocked" state and Auto-Yes's chance to
+ * adjudicate it — which matters more here than anywhere else, because an
+ * unanswered opencode approval waits forever (#1758 §5.5.3).
+ *
+ * Not the same contract as `recheckPendingDecisions` (#1898), which answers the
+ * *policy changed* trigger of §4 D3 decision 3 and adjudicates directly. This
+ * one replays the frames so the whole ingest path runs, and the two cannot
+ * double-answer one approval: an id delivered here is in `seenDecisions`, and an
+ * approval adjudicated there has already left through `answerPendingDecision`,
+ * which is idempotent per decision id.
  */
 async function resyncPending(state) {
     const now = Date.now();
@@ -288,7 +430,20 @@ async function resyncPending(state) {
         (0, client_1.fetchOpencodePendingQuestions)(state.port),
     ]);
     const replay = (entries, type) => {
-        for (const entry of entries) {
+        // DR4-009: bounded, and the overflow is counted rather than dropped in
+        // silence. Same limit and same reason as `MAX_RECHECKED_DECISIONS`.
+        const kept = entries.slice(0, exports.MAX_RESYNCED_DECISIONS);
+        if (entries.length > kept.length) {
+            logger.warn('opencode-resync-truncated', {
+                worktreeId: state.target.worktreeId,
+                instanceId: state.target.instanceId ?? state.target.cliToolId,
+                type,
+                examined: kept.length,
+                skipped: entries.length - kept.length,
+                limit: exports.MAX_RESYNCED_DECISIONS,
+            });
+        }
+        for (const entry of kept) {
             const id = (0, event_mapper_1.readStringField)(entry, 'id');
             if (!id || state.seenDecisions.has(id))
                 continue;
@@ -300,6 +455,79 @@ async function resyncPending(state) {
     replay(permissions, 'permission.asked');
     replay(questions, 'question.asked');
 }
+/**
+ * Work out what happened to the turn while the connection was down (Issue
+ * #1900 item 1, §4 D3 `closedBy: 'resync_idle'`).
+ *
+ * `?after=<seq>` returns zero bytes on this server, so a reconnect cannot ask
+ * what it missed. What it *can* ask is what is true now, and `GET /session/status`
+ * answers per session. Two things follow from one reply:
+ *
+ *  - **`busy` re-arms.** Without this the gate is empty, the `session.idle` that
+ *    eventually arrives is dropped as `never-armed`, and the instance reads
+ *    `running` off its last `post_tool_use` for the whole thirty-minute
+ *    staleness bound. That is the reported failure: a watchdog trip mid-turn
+ *    cost the `stop` entirely.
+ *  - **`idle` for a session that *was* armed is the completion that was lost.**
+ *    It is synthesised into the same `session.idle` frame the live path would
+ *    have carried, so it goes through the gate, the mapper and the ingest
+ *    unchanged. Only an explicit `idle` counts — a session missing from the
+ *    reply says nothing, and guessing there would resolve a `wait` on absence.
+ *
+ * Re-arming runs first so the primary session is claimed by something that is
+ * genuinely working before any synthesised idle can claim it.
+ *
+ * Gated on the declared {@link SourceResync}: a source that says `'none'` has no
+ * endpoint to poll and this must be a no-op for it.
+ *
+ * @param armedBefore - Sessions the gate had mid-turn when the stream dropped
+ */
+async function recoverTurnState(state, armedBefore) {
+    if (state.resync !== 'session-status-poll')
+        return;
+    const statuses = await (0, client_1.fetchOpencodeSessionStatuses)(state.port);
+    if (statuses === null) {
+        // Unreachable between the health probe and here. Nothing is claimed, and
+        // the scraper decides — which is the pre-#1900 outcome, not a new one.
+        logger.info('opencode-resync-status-unavailable', {
+            worktreeId: state.target.worktreeId,
+            instanceId: state.target.instanceId ?? state.target.cliToolId,
+            port: state.port,
+        });
+        return;
+    }
+    const rearmed = [];
+    for (const [sessionId, activity] of Object.entries(statuses)) {
+        if (activity !== 'busy')
+            continue;
+        state.gate.arm(sessionId);
+        rearmed.push(sessionId);
+    }
+    const synthesized = [];
+    for (const sessionId of armedBefore) {
+        if (statuses[sessionId] !== 'idle')
+            continue;
+        // Armed so the gate reads the synthesised frame as a completion rather than
+        // as the `never-armed` idle its own reset just made it.
+        state.gate.arm(sessionId);
+        synthesized.push(sessionId);
+        deliver(state, {
+            id: `resync_idle_${sessionId}`,
+            type: 'session.idle',
+            properties: { sessionID: sessionId },
+        }, Date.now());
+    }
+    if (rearmed.length > 0 || synthesized.length > 0) {
+        logger.info('opencode-turn-state-recovered', {
+            worktreeId: state.target.worktreeId,
+            instanceId: state.target.instanceId ?? state.target.cliToolId,
+            port: state.port,
+            rearmed,
+            synthesized,
+            primarySession: state.gate.primarySession(),
+        });
+    }
+}
 /** Process one frame off the stream. */
 function handleFrame(state, frame) {
     const type = (0, event_mapper_1.readStringField)(frame, 'type');