fix(client): derive auto-open listen filter from configured ∩ server-advertised

`_connectNegotiated` now computes `effective = configured ∩ serverAdvertised`
ONCE after discover and uses that single value for BOTH
`_setupListChangedHandlers` and the auto-open `subscriptions/listen` filter.
A configured-but-not-advertised type (e.g. tools configured but the server
doesn't advertise tools.listChanged) is neither subscribed to nor handled,
so the filter and the registered handlers stay in lockstep. When the
intersection is empty, auto-open is skipped entirely.

(Squash-carried: TS narrow-cast on the synchronous-termination unpark
guard — control-flow narrowing does not track closure mutation.)

Author: felixweinberger

packages/client/src/client/client.ts

@@ -862,12 +862,22 @@ export class Client extends Protocol<ClientContext> {
         // 2025-era unsolicited notifications, no listen needed.
         if (this._pendingListChangedConfig) {
             const config = this._pendingListChangedConfig;
-            this._setupListChangedHandlers(config);
             this._pendingListChangedConfig = undefined;
+            // Compute configured ∩ server-advertised ONCE and use that single
+            // value for BOTH handler registration and the auto-open filter, so
+            // a configured-but-not-advertised type is neither subscribed to
+            // nor handled (the two stay in lockstep).
+            const advertised = this._serverCapabilities;
+            const effective: ListChangedHandlers = {
+                ...(config.tools && advertised?.tools?.listChanged && { tools: config.tools }),
+                ...(config.prompts && advertised?.prompts?.listChanged && { prompts: config.prompts }),
+                ...(config.resources && advertised?.resources?.listChanged && { resources: config.resources })
+            };
+            this._setupListChangedHandlers(effective);
             const filter: SubscriptionFilter = {
-                ...(config.tools && { toolsListChanged: true as const }),
-                ...(config.prompts && { promptsListChanged: true as const }),
-                ...(config.resources && { resourcesListChanged: true as const })
+                ...(effective.tools && { toolsListChanged: true as const }),
+                ...(effective.prompts && { promptsListChanged: true as const }),
+                ...(effective.resources && { resourcesListChanged: true as const })
             };
             if (Object.keys(filter).length > 0) {
                 // A failed auto-open MUST NOT fail connect: the modern
@@ -1354,8 +1364,9 @@ export class Client extends Protocol<ClientContext> {
             );
             // A synchronously-delivered termination during `send()` (an
             // in-process transport) ran `settle()` before `parked` was
-            // assigned — unpark now so the handler does not leak.
-            if (state === 'closed') parked.unpark();
+            // assigned — unpark now so the handler does not leak. (Cast: TS
+            // control-flow narrowing does not track closure mutation.)
+            if ((state as 'opening' | 'open' | 'closed') === 'closed') parked.unpark();
             // Pre-ack capacity / params rejection arrives as a JSON-RPC error
             // for the listen id; transport close is delivered the same way.
             void parked.terminated.then(({ reason, error }) => {

packages/client/test/client/listen.test.ts

@@ -288,6 +288,35 @@ describe('Client.listen()', () => {
         expect(client.getNegotiatedProtocolVersion()).toBeUndefined();
     });
 
+    it('auto-open filter is configured ∩ server-advertised; empty intersection skips auto-open', async () => {
+        const filters: unknown[] = [];
+        // scriptedModern advertises tools.listChanged + prompts.listChanged but NOT resources.
+        const { clientTx } = await scriptedModern((_id, filter) => filters.push(filter));
+        const onChanged = () => {};
+        const client = new Client(
+            { name: 'c', version: '1' },
+            // Configures tools + resources; server advertises tools + prompts.
+            { versionNegotiation: { mode: 'auto' }, listChanged: { tools: { onChanged }, resources: { onChanged } } }
+        );
+        await client.connect(clientTx);
+        // Intersection = tools only.
+        expect(filters).toEqual([{ toolsListChanged: true }]);
+        expect(client.autoOpenedSubscription?.honoredFilter).toEqual({ toolsListChanged: true });
+        await client.close();
+
+        // Empty intersection: configures resources only; server advertises tools+prompts.
+        const filters2: unknown[] = [];
+        const { clientTx: clientTx2 } = await scriptedModern((_id, filter) => filters2.push(filter));
+        const client2 = new Client(
+            { name: 'c', version: '1' },
+            { versionNegotiation: { mode: 'auto' }, listChanged: { resources: { onChanged } } }
+        );
+        await client2.connect(clientTx2);
+        expect(filters2).toEqual([]);
+        expect(client2.autoOpenedSubscription).toBeUndefined();
+        await client2.close();
+    });
+
     it('a failed auto-open surfaces via onerror and does NOT fail connect', async () => {
         const [clientTx, serverTx] = InMemoryTransport.createLinkedPair();
         serverTx.onmessage = m => {