@agentdeck/bridge 1.0.24 → 1.1.0

package/dist/adapters/openclaw.d.ts

@@ -58,10 +58,29 @@ export declare class OpenClawAdapter extends EventEmitter implements AgentAdapte
     private apmeSessionId;
     private apmeTraceId;
     private apmeCwdHint;
-    /** Idle-gap timer — fires the `task_boundary` (idle_gap) span when the
-     *  user hasn't sent a new `chat.send` for OPENCLAW_IDLE_GAP_MS after the
-     *  last `chat.final`. Reset on every new send, cleared on session end. */
-    private apmeIdleTimer;
+    /** Opens (or returns) the APME run for one Gateway session key. Supplied by
+     *  the daemon, which owns the collector. */
+    private apmeRunFor;
+    /** Per-Gateway-session-key APME state.
+     *
+     *  **Why this is keyed by session key and not by connection.** One Gateway
+     *  connection sees every session the agent has: the chat the user is looking
+     *  at (`agent:main:main`), each cron job (`agent:main:cron:<id>`), and one
+     *  fresh key per model-eval run (`agent:main:eval-…__r2` — a suite opens six
+     *  in three hours). A run scoped to the connection therefore interleaves all
+     *  of them into one trajectory under one `model_id`, and the idle-gap
+     *  boundary is computed across traffic from conversations that have nothing
+     *  to do with each other. Turn ordering, per-task cost and every judge
+     *  verdict derived from them describe a conversation that never happened.
+     *
+     *  Each entry owns its own idle-gap timer for the same reason: a cron
+     *  heartbeat firing every few minutes would otherwise keep resetting the
+     *  timer for a user chat that ended half an hour ago, and that task would
+     *  never close — a task that never closes is never evaluated. */
+    private apmeBySessionKey;
+    /** Idle-gap timer for frames that arrive without a session key (the
+     *  connection-scoped fallback run). */
+    private apmeFallbackIdleTimer;
     /** Reconnect delay (doubles on each failure, max 30s) */
     private reconnectDelay;
     private static readonly MAX_RECONNECT_DELAY;
@@ -70,17 +89,52 @@ export declare class OpenClawAdapter extends EventEmitter implements AgentAdapte
     /** Bind the adapter to an APME session id so Gateway events can be
      *  ingested as TelemetrySpans. No-op when APME isn't initialized. */
     setApmeSession(sessionId: string, cwd?: string): void;
+    /** Install the per-session-key run opener. The daemon owns the collector, so
+     *  the adapter asks it for the APME session id belonging to a Gateway
+     *  session key and caches the answer. Returning `null` (APME disabled, or
+     *  `openRun` threw) makes that key fall back to the connection-scoped id,
+     *  which is the pre-split behaviour rather than silence. */
+    setApmeRunResolver(resolve: (sessionKey: string) => string | null): void;
+    /** APME session ids this adapter has opened, so the daemon can close them
+     *  all when the Gateway link drops. */
+    apmeSessionIds(): string[];
     /** True when this adapter pipes Gateway events into the APME collector
      *  itself — the bridge must then NOT also convert its timeline entries to
      *  spans, or every turn and tool would be counted twice. */
     hasDirectApmeIngestion(): boolean;
+    /** Resolve the APME context for a Gateway session key.
+     *
+     *  A frame with no session key falls back to the connection-scoped id — that
+     *  is what the adapter had before the split, and dropping such a frame would
+     *  trade a mis-scoped record for no record at all. */
     private buildApmeCtx;
+    /** Get-or-create the per-session-key entry — WITHOUT opening its APME run.
+     *
+     *  Opening the run here is what a first version did, and it manufactured
+     *  exactly the noise this whole split exists to remove: a context is built
+     *  for every frame, including ones that parse to zero spans, so a real
+     *  `agent:main:main:heartbeat` key opened a run holding 0 turns, 0 steps and
+     *  0 events (measured on live traffic 2026-08-23). The Gateway filters
+     *  heartbeat message pairs out of `session.message`, so such a key can emit
+     *  frames that carry nothing to record. A run is opened on the first span
+     *  that is actually ingested. */
+    private apmeEntryFor;
+    /** The APME session id for a key, opening its run on first use. */
+    private apmeSessionIdFor;
+    /** Ingest spans against the run belonging to `sessionKey`.
+     *
+     *  The target must be re-resolved from the key, never read off
+     *  `this.apmeSessionId` — reading that field here is what would silently
+     *  re-collapse every per-key run back into one. Returns early on an empty
+     *  span list so no run is opened for a frame that records nothing. */
     private ingestApmeSpans;
     /** Reset (or start) the idle-gap timer. Fires
      *  `openclawIdleGapTaskBoundary` after OPENCLAW_IDLE_GAP_MS of silence
      *  (no new `chat.send`) following the last `chat.final`. */
     private armIdleGapTimer;
     private clearIdleGapTimer;
+    /** Clear every per-key timer (shutdown). */
+    private clearAllIdleGapTimers;
     start(options: AdapterStartOptions & {
         externalServer?: Server;
     }): Promise<void>;
@@ -162,6 +216,22 @@ export declare class OpenClawAdapter extends EventEmitter implements AgentAdapte
      * Called when Gateway sends `connect.challenge` event with nonce.
      */
     private sendConnectRequest;
+    /** Join the Gateway's session event stream (`sessions.subscribe`, scope
+     *  `operator.read`).
+     *
+     *  The Gateway's recipient set for `session.message` is
+     *  `sessionEventSubscribers ∪ sessionMessageSubscribers`, and the former is
+     *  unioned in unconditionally — so this one no-param call delivers the
+     *  messages of EVERY session, which is what we want: AgentDeck observes the
+     *  whole agent, not one chat. `sessions.messages.subscribe` is the per-key
+     *  alternative and would need a subscribe/unsubscribe cycle for every
+     *  session key the store mints (an eval suite opens a fresh one per run), so
+     *  it is the wrong shape here.
+     *
+     *  Failure is non-fatal and stays visible: without the subscription the
+     *  adapter degrades to exactly its previous behaviour (chat + approvals
+     *  only), which is a smaller timeline, not a broken one. */
+    private subscribeSessionEvents;
     /** Fetch sessions and set the most recently updated one as active. */
     private fetchSessions;
     /** Fetch model catalog via CLI and emit events. Retries once on failure. */

package/dist/adapters/openclaw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openclaw.d.ts","sourceRoot":"","sources":["../../src/adapters/openclaw.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"openclaw.d.ts","sourceRoot":"","sources":["../../src/adapters/openclaw.ts"],"names":[],"mappings":"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"}

package/dist/adapters/openclaw.js

@@ -94,10 +94,29 @@ export class OpenClawAdapter extends EventEmitter {
     apmeSessionId = null;
     apmeTraceId = randomUUID();
     apmeCwdHint;
-    /** Idle-gap timer — fires the `task_boundary` (idle_gap) span when the
-     *  user hasn't sent a new `chat.send` for OPENCLAW_IDLE_GAP_MS after the
-     *  last `chat.final`. Reset on every new send, cleared on session end. */
-    apmeIdleTimer = null;
+    /** Opens (or returns) the APME run for one Gateway session key. Supplied by
+     *  the daemon, which owns the collector. */
+    apmeRunFor = null;
+    /** Per-Gateway-session-key APME state.
+     *
+     *  **Why this is keyed by session key and not by connection.** One Gateway
+     *  connection sees every session the agent has: the chat the user is looking
+     *  at (`agent:main:main`), each cron job (`agent:main:cron:<id>`), and one
+     *  fresh key per model-eval run (`agent:main:eval-…__r2` — a suite opens six
+     *  in three hours). A run scoped to the connection therefore interleaves all
+     *  of them into one trajectory under one `model_id`, and the idle-gap
+     *  boundary is computed across traffic from conversations that have nothing
+     *  to do with each other. Turn ordering, per-task cost and every judge
+     *  verdict derived from them describe a conversation that never happened.
+     *
+     *  Each entry owns its own idle-gap timer for the same reason: a cron
+     *  heartbeat firing every few minutes would otherwise keep resetting the
+     *  timer for a user chat that ended half an hour ago, and that task would
+     *  never close — a task that never closes is never evaluated. */
+    apmeBySessionKey = new Map();
+    /** Idle-gap timer for frames that arrive without a session key (the
+     *  connection-scoped fallback run). */
+    apmeFallbackIdleTimer = null;
     /** Reconnect delay (doubles on each failure, max 30s) */
     reconnectDelay = 1000;
     static MAX_RECONNECT_DELAY = 30_000;
@@ -155,30 +174,103 @@ export class OpenClawAdapter extends EventEmitter {
         this.apmeSessionId = sessionId;
         this.apmeCwdHint = cwd;
     }
+    /** Install the per-session-key run opener. The daemon owns the collector, so
+     *  the adapter asks it for the APME session id belonging to a Gateway
+     *  session key and caches the answer. Returning `null` (APME disabled, or
+     *  `openRun` threw) makes that key fall back to the connection-scoped id,
+     *  which is the pre-split behaviour rather than silence. */
+    setApmeRunResolver(resolve) {
+        this.apmeRunFor = resolve;
+    }
+    /** APME session ids this adapter has opened, so the daemon can close them
+     *  all when the Gateway link drops. */
+    apmeSessionIds() {
+        return [...this.apmeBySessionKey.values()]
+            .map((e) => e.sessionId)
+            .filter((id) => id !== null);
+    }
     /** True when this adapter pipes Gateway events into the APME collector
      *  itself — the bridge must then NOT also convert its timeline entries to
      *  spans, or every turn and tool would be counted twice. */
     hasDirectApmeIngestion() {
         return this.apmeSessionId != null && getApme() != null;
     }
-    buildApmeCtx() {
-        if (!this.apmeSessionId || !getApme())
+    /** Resolve the APME context for a Gateway session key.
+     *
+     *  A frame with no session key falls back to the connection-scoped id — that
+     *  is what the adapter had before the split, and dropping such a frame would
+     *  trade a mis-scoped record for no record at all. */
+    buildApmeCtx(sessionKey) {
+        if (!getApme())
+            return null;
+        const entry = sessionKey ? this.apmeEntryFor(sessionKey) : null;
+        // `sessionId` here is provisional: for a keyed context the run may not be
+        // open yet (see `apmeEntryFor`), and `ingestApmeSpans` re-resolves it
+        // against `sessionKey` before writing anything. It is never read into a
+        // span attribute — only used to route the ingest.
+        const sessionId = entry?.sessionId ?? this.apmeSessionId;
+        if (!sessionId && !entry)
             return null;
         return {
-            sessionId: this.apmeSessionId,
+            sessionId: sessionId ?? '',
             agentType: 'openclaw',
             cwd: this.apmeCwdHint,
-            traceId: this.apmeTraceId,
+            traceId: entry?.traceId ?? this.apmeTraceId,
             activeTurnId: undefined,
         };
     }
-    ingestApmeSpans(spans) {
+    /** Get-or-create the per-session-key entry — WITHOUT opening its APME run.
+     *
+     *  Opening the run here is what a first version did, and it manufactured
+     *  exactly the noise this whole split exists to remove: a context is built
+     *  for every frame, including ones that parse to zero spans, so a real
+     *  `agent:main:main:heartbeat` key opened a run holding 0 turns, 0 steps and
+     *  0 events (measured on live traffic 2026-08-23). The Gateway filters
+     *  heartbeat message pairs out of `session.message`, so such a key can emit
+     *  frames that carry nothing to record. A run is opened on the first span
+     *  that is actually ingested. */
+    apmeEntryFor(sessionKey) {
+        const existing = this.apmeBySessionKey.get(sessionKey);
+        if (existing)
+            return existing;
+        if (!this.apmeRunFor)
+            return null;
+        const entry = { sessionId: null, traceId: randomUUID(), idleTimer: null };
+        this.apmeBySessionKey.set(sessionKey, entry);
+        return entry;
+    }
+    /** The APME session id for a key, opening its run on first use. */
+    apmeSessionIdFor(sessionKey) {
+        const entry = this.apmeEntryFor(sessionKey);
+        if (!entry)
+            return null;
+        if (entry.sessionId)
+            return entry.sessionId;
+        const sessionId = this.apmeRunFor?.(sessionKey) ?? null;
+        if (!sessionId)
+            return null;
+        entry.sessionId = sessionId;
+        debug('adapter:openclaw', `APME run opened for ${sessionKey} → ${sessionId.slice(0, 16)}`);
+        return sessionId;
+    }
+    /** Ingest spans against the run belonging to `sessionKey`.
+     *
+     *  The target must be re-resolved from the key, never read off
+     *  `this.apmeSessionId` — reading that field here is what would silently
+     *  re-collapse every per-key run back into one. Returns early on an empty
+     *  span list so no run is opened for a frame that records nothing. */
+    ingestApmeSpans(sessionKey, spans) {
         const apme = getApme();
-        if (!apme || !this.apmeSessionId || spans.length === 0)
+        if (!apme || spans.length === 0)
+            return;
+        const target = sessionKey
+            ? this.apmeSessionIdFor(sessionKey) ?? this.apmeSessionId
+            : this.apmeSessionId;
+        if (!target)
             return;
         for (const span of spans) {
             try {
-                apme.collector.ingestSpan(this.apmeSessionId, span);
+                apme.collector.ingestSpan(target, span);
             }
             catch (err) {
                 debug('apme:openclaw', `ingestSpan failed: ${String(err)}`);
@@ -188,19 +280,29 @@ export class OpenClawAdapter extends EventEmitter {
     /** Reset (or start) the idle-gap timer. Fires
      *  `openclawIdleGapTaskBoundary` after OPENCLAW_IDLE_GAP_MS of silence
      *  (no new `chat.send`) following the last `chat.final`. */
-    armIdleGapTimer() {
-        this.clearIdleGapTimer();
-        const ctx = this.buildApmeCtx();
+    armIdleGapTimer(sessionKey) {
+        this.clearIdleGapTimer(sessionKey);
+        const ctx = this.buildApmeCtx(sessionKey);
         if (!ctx)
             return;
-        this.apmeIdleTimer = setTimeout(() => {
-            this.apmeIdleTimer = null;
+        const holder = sessionKey ? this.apmeBySessionKey.get(sessionKey) : null;
+        const timer = setTimeout(() => {
+            if (holder)
+                holder.idleTimer = null;
+            else
+                this.apmeFallbackIdleTimer = null;
             const apme = getApme();
-            if (!apme || !this.apmeSessionId)
+            if (!apme)
+                return;
+            // Resolve at FIRE time, and never open a run here: a boundary closing a
+            // task that was never opened would mint an empty run at the exact moment
+            // the conversation went quiet.
+            const target = holder?.sessionId ?? (sessionKey ? null : this.apmeSessionId);
+            if (!target)
                 return;
             const span = openclawIdleGapTaskBoundary(ctx);
             try {
-                apme.collector.ingestSpan(this.apmeSessionId, span);
+                apme.collector.ingestSpan(target, span);
             }
             catch (err) {
                 debug('apme:openclaw', `idle_gap ingestSpan failed: ${String(err)}`);
@@ -208,14 +310,35 @@ export class OpenClawAdapter extends EventEmitter {
         }, OPENCLAW_IDLE_GAP_MS);
         // Don't keep the event loop alive just for this timer; the adapter is
         // already pinning the loop via WebSocket.
-        this.apmeIdleTimer.unref?.();
+        timer.unref?.();
+        if (holder)
+            holder.idleTimer = timer;
+        else
+            this.apmeFallbackIdleTimer = timer;
     }
-    clearIdleGapTimer() {
-        if (this.apmeIdleTimer) {
-            clearTimeout(this.apmeIdleTimer);
-            this.apmeIdleTimer = null;
+    clearIdleGapTimer(sessionKey) {
+        const holder = sessionKey ? this.apmeBySessionKey.get(sessionKey) : null;
+        if (holder) {
+            if (holder.idleTimer)
+                clearTimeout(holder.idleTimer);
+            holder.idleTimer = null;
+            return;
+        }
+        if (this.apmeFallbackIdleTimer) {
+            clearTimeout(this.apmeFallbackIdleTimer);
+            this.apmeFallbackIdleTimer = null;
         }
     }
+    /** Clear every per-key timer (shutdown). */
+    clearAllIdleGapTimers() {
+        for (const entry of this.apmeBySessionKey.values()) {
+            if (entry.idleTimer)
+                clearTimeout(entry.idleTimer);
+            entry.idleTimer = null;
+        }
+        // ...and the keyless fallback timer.
+        this.clearIdleGapTimer();
+    }
     async start(options) {
         if (options.gatewayUrl) {
             this.gatewayUrl = options.gatewayUrl;
@@ -290,7 +413,16 @@ export class OpenClawAdapter extends EventEmitter {
     }
     setPendingApproval(prompt) {
         this.clearPendingApproval();
-        this.pendingApproval = prompt;
+        // Which OpenClaw session asked is the single most orienting fact about an
+        // approval — `agent:main:main` (the chat the user is looking at) vs
+        // `agent:main:cron:<id>` vs `agent:main:eval-…__r2` are wildly different
+        // things to approve, and the deck row is pinned to the literal "OpenClaw"
+        // for all of them. The Gateway does not always put `sessionKey` on the
+        // approval body, but the adapter has been tracking it off the chat stream
+        // all along, so fall back to that rather than surfacing nothing.
+        this.pendingApproval = prompt.sessionKey || !this.currentSessionKey
+            ? prompt
+            : { ...prompt, sessionKey: this.currentSessionKey };
         if (typeof prompt.expiresAtMs === 'number') {
             const delay = prompt.expiresAtMs - Date.now();
             // An already-expired stamp still needs the sweep to run (on the next
@@ -319,7 +451,12 @@ export class OpenClawAdapter extends EventEmitter {
         this.clearPendingApproval();
         this.emitTimelineEntry({
             ts: Date.now(), type: 'tool_resolved', raw: `Not approved · ${reason}`,
-            approvalId, status: 'denied',
+            // NOT `denied` — nobody refused this. It expired, its run was cancelled,
+            // its turn ended, or the link dropped. Writing `denied` here made a user's
+            // deliberate refusal byte-identical to an approval that was never
+            // answered, which is the commoner case by far and the one that means the
+            // prompt failed to reach a human in time. `raw` names which of the four.
+            approvalId, status: 'abandoned',
         });
         this.emitAdapterEvent({ source: 'parser', event: 'idle' });
     }
@@ -453,10 +590,10 @@ export class OpenClawAdapter extends EventEmitter {
                     // APME: open a turn. The matching `turn_response` lands on
                     // `chat.final` below. Cancel any pending idle-gap timer — a new
                     // send means the conversation is still active.
-                    const ctx = this.buildApmeCtx();
+                    const ctx = this.buildApmeCtx(this.currentSessionKey);
                     if (ctx) {
-                        this.clearIdleGapTimer();
-                        this.ingestApmeSpans([openclawChatSendToSpan(ctx, cmd.text)]);
+                        this.clearIdleGapTimer(this.currentSessionKey);
+                        this.ingestApmeSpans(this.currentSessionKey, [openclawChatSendToSpan(ctx, cmd.text)]);
                     }
                     this.rpcCall('chat.send', {
                         sessionKey: this.currentSessionKey,
@@ -560,7 +697,7 @@ export class OpenClawAdapter extends EventEmitter {
             this.reconnectTimer = null;
         }
         // Cancel any pending idle-gap timer so it doesn't fire after shutdown.
-        this.clearIdleGapTimer();
+        this.clearAllIdleGapTimers();
         for (const [id, pending] of this.pendingRpc) {
             pending.reject(new Error('Adapter shutting down'));
             this.pendingRpc.delete(id);
@@ -985,7 +1122,7 @@ export class OpenClawAdapter extends EventEmitter {
                         // OPENCLAW_IDLE_GAP_MS the timer is cancelled (above in
                         // `send_prompt`); otherwise it fires `task_boundary` (idle_gap)
                         // and closes the task.
-                        const apmeCtx = this.buildApmeCtx();
+                        const apmeCtx = this.buildApmeCtx(sessionKey);
                         if (apmeCtx) {
                             const apmePayload = {
                                 state: 'final',
@@ -994,8 +1131,8 @@ export class OpenClawAdapter extends EventEmitter {
                                 ...(responseContent ? { response: responseContent } : {}),
                                 ...(Array.isArray(payload.tools) ? { tools: payload.tools } : {}),
                             };
-                            this.ingestApmeSpans(openclawChatEventToSpans(apmeCtx, apmePayload));
-                            this.armIdleGapTimer();
+                            this.ingestApmeSpans(sessionKey, openclawChatEventToSpans(apmeCtx, apmePayload));
+                            this.armIdleGapTimer(sessionKey);
                         }
                         this.chatStarted = false;
                         this.lastPrompt = null;
@@ -1022,10 +1159,10 @@ export class OpenClawAdapter extends EventEmitter {
                         // APME: emit task_boundary so the abort itself closes the task
                         // immediately \u2014 don't wait for the idle timer. The user
                         // explicitly stopped this turn.
-                        const abortCtx = this.buildApmeCtx();
+                        const abortCtx = this.buildApmeCtx(sessionKey);
                         if (abortCtx) {
-                            this.clearIdleGapTimer();
-                            this.ingestApmeSpans(openclawChatEventToSpans(abortCtx, {
+                            this.clearIdleGapTimer(sessionKey);
+                            this.ingestApmeSpans(sessionKey, openclawChatEventToSpans(abortCtx, {
                                 state: 'aborted',
                                 ...(payload.runId ? { runId: payload.runId } : {}),
                                 ...(payload.sessionKey ? { sessionKey: payload.sessionKey } : {}),
@@ -1082,10 +1219,10 @@ export class OpenClawAdapter extends EventEmitter {
                         // idle-gap timer. `chat.send` cleared that timer and only `final`
                         // used to re-arm it, so a prompt that errored and was then
                         // abandoned left its task open indefinitely.
-                        const errCtx = this.buildApmeCtx();
+                        const errCtx = this.buildApmeCtx(sessionKey);
                         if (errCtx) {
-                            this.ingestApmeSpans(openclawChatEventToSpans(errCtx, errInput));
-                            this.armIdleGapTimer();
+                            this.ingestApmeSpans(sessionKey, openclawChatEventToSpans(errCtx, errInput));
+                            this.armIdleGapTimer(sessionKey);
                         }
                         this.chatStarted = false;
                         this.lastPrompt = null;
@@ -1198,15 +1335,27 @@ export class OpenClawAdapter extends EventEmitter {
             // trajectory empty of detail. Route them into the APME normalizer so the
             // SessionSample captures the full tool-use trajectory (req #6).
             case 'session.tool': {
-                const apmeCtx = this.buildApmeCtx();
+                const toolPayload = payload;
+                const apmeCtx = this.buildApmeCtx(toolPayload.sessionKey);
                 if (apmeCtx)
-                    this.ingestApmeSpans(openclawSessionToolToSpans(apmeCtx, payload));
+                    this.ingestApmeSpans(toolPayload.sessionKey, openclawSessionToolToSpans(apmeCtx, toolPayload));
                 break;
             }
             case 'session.message': {
-                const apmeCtx = this.buildApmeCtx();
-                if (apmeCtx)
-                    this.ingestApmeSpans(openclawSessionMessageToSpans(apmeCtx, payload));
+                const msgPayload = payload;
+                const apmeCtx = this.buildApmeCtx(msgPayload.sessionKey);
+                if (!apmeCtx)
+                    break;
+                this.ingestApmeSpans(msgPayload.sessionKey, openclawSessionMessageToSpans(apmeCtx, msgPayload));
+                // A user message re-opens the conversation: cancel the pending
+                // idle-gap boundary for THIS key so a follow-up question stays in the
+                // same task. An assistant message means the turn just landed, so the
+                // gap starts counting from here.
+                const role = (msgPayload.message?.role ?? '').toLowerCase();
+                if (role === 'user')
+                    this.clearIdleGapTimer(msgPayload.sessionKey);
+                else if (role === 'assistant')
+                    this.armIdleGapTimer(msgPayload.sessionKey);
                 break;
             }
             default:
@@ -1289,6 +1438,21 @@ export class OpenClawAdapter extends EventEmitter {
                 this.fetchSessions().catch(err => debug('adapter:openclaw', `fetchSessions error: ${err}`));
                 // Fetch model catalog (async, non-blocking)
                 this.emitModelCatalog().catch(err => debug('adapter:openclaw', `emitModelCatalog error: ${err}`));
+                // Subscribe to the session event stream. Without this call the
+                // Gateway puts us in NEITHER `sessionEventSubscribers` nor
+                // `sessionMessageSubscribers`, and those two sets are the entire
+                // recipient list for `session.message` and `session.tool` — so the
+                // handlers for both events below have existed since they were written
+                // without ever receiving one frame. That is what left APME with 657 of
+                // 665 OpenClaw runs holding zero turns: the `chat` frame carries only
+                // the ASSISTANT message, so nothing ever opened a turn for a
+                // conversation the user started in the OpenClaw app, and a
+                // `turn_response` with no open turn is dropped on the floor
+                // (`Collector.setTurnResponse` → `if (!turnId) return`).
+                //
+                // `operator.read` is already in our requested scopes (it is what
+                // `sessions.list` runs under), so this needs no new permission.
+                this.subscribeSessionEvents().catch(err => debug('adapter:openclaw', `subscribeSessionEvents error: ${err}`));
                 // Catch up on approvals that were already waiting. `exec.approval.requested`
                 // is a broadcast and is never replayed, so without this read a daemon
                 // restart (or any Gateway reconnect) leaves the agent blocked on an
@@ -1318,6 +1482,34 @@ export class OpenClawAdapter extends EventEmitter {
             debug('adapter:openclaw', `Failed to send connect request: ${err}`);
         }
     }
+    /** Join the Gateway's session event stream (`sessions.subscribe`, scope
+     *  `operator.read`).
+     *
+     *  The Gateway's recipient set for `session.message` is
+     *  `sessionEventSubscribers ∪ sessionMessageSubscribers`, and the former is
+     *  unioned in unconditionally — so this one no-param call delivers the
+     *  messages of EVERY session, which is what we want: AgentDeck observes the
+     *  whole agent, not one chat. `sessions.messages.subscribe` is the per-key
+     *  alternative and would need a subscribe/unsubscribe cycle for every
+     *  session key the store mints (an eval suite opens a fresh one per run), so
+     *  it is the wrong shape here.
+     *
+     *  Failure is non-fatal and stays visible: without the subscription the
+     *  adapter degrades to exactly its previous behaviour (chat + approvals
+     *  only), which is a smaller timeline, not a broken one. */
+    async subscribeSessionEvents() {
+        const result = await this.rpcCall('sessions.subscribe', {});
+        const subscribed = !!(result && typeof result === 'object'
+            && result.subscribed);
+        if (!subscribed) {
+            // The Gateway answers `{subscribed:false}` when the connection has no
+            // `connId` — a real refusal, not a transport error, so it never lands in
+            // the catch above.
+            logError('[adapter:openclaw] sessions.subscribe returned subscribed:false — session.message/session.tool will not arrive');
+            return;
+        }
+        debug('adapter:openclaw', 'sessions.subscribe ok');
+    }
     /** Fetch sessions and set the most recently updated one as active. */
     async fetchSessions() {
         try {