fix(ocap-kernel): fix DGC e2e tests using wrong remote ID and isolated store cache

The DGC e2e tests had two compounding bugs: they called scheduleReap('r0')
but the first allocated remote is r1, and they used a separate KernelStore
instance whose cache was isolated from the kernel's internal store.

Add reapRemotes() to RemoteManager and Kernel (mirroring reapVats) and
use it in the e2e tests instead of bypassing the kernel with an external
store. Remove getGCActions() and nextRemoteId assertions that suffered
from the same stale cache issue.

Also reset #remoteGcRequested flag in handlePeerRestart() so BOYD is
correctly sent to a new incarnation after peer restart.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sirtimid

packages/nodejs/test/e2e/remote-comms.test.ts

@@ -1036,19 +1036,16 @@ describe.sequential('Remote Communications E2E', () => {
         );
 
         // Send a message to create cross-kernel object references
-        await sendRemoteMessage(kernel1, aliceRef, bobURL, 'hello', ['Alice']);
-
-        // Verify remote endpoint was allocated on kernel1
-        const nextRemoteId1 = Number(
-          kernelStore1.kv.get('nextRemoteId') ?? '0',
+        const response = await sendRemoteMessage(
+          kernel1,
+          aliceRef,
+          bobURL,
+          'hello',
+          ['Alice'],
         );
-        expect(nextRemoteId1).toBeGreaterThan(0);
 
-        // Verify remote endpoint was allocated on kernel2
-        const nextRemoteId2 = Number(
-          kernelStore2.kv.get('nextRemoteId') ?? '0',
-        );
-        expect(nextRemoteId2).toBeGreaterThan(0);
+        // Verify cross-kernel communication works (implies remote endpoints were created)
+        expect(response).toContain('vat Bob got "hello" from Alice');
       },
       NETWORK_TIMEOUT,
     );
@@ -1067,9 +1064,9 @@ describe.sequential('Remote Communications E2E', () => {
         // Send a message to create cross-kernel refs
         await sendRemoteMessage(kernel1, aliceRef, bobURL, 'hello', ['Alice']);
 
-        // Schedule reap on kernel1's remote endpoint (r0) - this will cause
+        // Schedule reap on kernel1's remote endpoints - this will cause
         // the crank loop to deliver BOYD to the remote kernel
-        kernelStore1.scheduleReap('r0');
+        kernel1.reapRemotes();
 
         // Trigger cranks to process the reap action (which sends BOYD to kernel2)
         // and allow the remote to process it and respond
@@ -1106,8 +1103,8 @@ describe.sequential('Remote Communications E2E', () => {
         await sendRemoteMessage(kernel1, aliceRef, bobURL, 'hello', ['Alice']);
         await sendRemoteMessage(kernel2, bobRef, aliceURL, 'hello', ['Bob']);
 
-        // Schedule reap on kernel2's remote endpoint - this will send BOYD to kernel1
-        kernelStore2.scheduleReap('r0');
+        // Schedule reap on kernel2's remote endpoints - this will send BOYD to kernel1
+        kernel2.reapRemotes();
 
         // Trigger cranks to process the reap and allow BOYD to flow
         for (let i = 0; i < 3; i++) {
@@ -1154,8 +1151,8 @@ describe.sequential('Remote Communications E2E', () => {
 
         // Schedule reap on BOTH sides simultaneously - this tests that the
         // ping-pong prevention flag works correctly, preventing infinite BOYD loops
-        kernelStore1.scheduleReap('r0');
-        kernelStore2.scheduleReap('r0');
+        kernel1.reapRemotes();
+        kernel2.reapRemotes();
 
         // Trigger cranks on both kernels to process the reaps and allow
         // BOYD messages to flow in both directions
@@ -1167,10 +1164,6 @@ describe.sequential('Remote Communications E2E', () => {
           await waitUntilQuiescent(500);
         }
 
-        // No pending GC actions on either side after DGC completes
-        expect(kernelStore1.getGCActions().size).toBe(0);
-        expect(kernelStore2.getGCActions().size).toBe(0);
-
         // Verify continued bidirectional communication works - this proves
         // the BOYD exchange completed without breaking the connection
         const aliceToBob = await sendRemoteMessage(

packages/ocap-kernel/src/Kernel.ts

@@ -14,6 +14,7 @@ import { makeKernelStore } from './store/index.ts';
 import type { KernelStore } from './store/index.ts';
 import type {
   VatId,
+  RemoteId,
   EndpointId,
   KRef,
   PlatformServices,
@@ -481,6 +482,16 @@ export class Kernel {
     this.#vatManager.reapVats(filter);
   }
 
+  /**
+   * Reap remotes that match the filter.
+   * This is for debugging and testing purposes only.
+   *
+   * @param filter - A function that returns true if the remote should be reaped.
+   */
+  reapRemotes(filter: (remoteId: RemoteId) => boolean = () => true): void {
+    this.#remoteManager.reapRemotes(filter);
+  }
+
   /**
    * Pin a vat root.
    *

packages/ocap-kernel/src/remotes/kernel/RemoteHandle.test.ts

@@ -1460,5 +1460,28 @@ describe('RemoteHandle', () => {
       // The pending redemption should be rejected
       await expect(redeemPromise).rejects.toThrow('Remote peer restarted');
     });
+
+    it('resets remoteGcRequested flag so BOYD is sent to new incarnation', async () => {
+      const remote = makeRemote();
+
+      // Receive BOYD from remote — sets the ping-pong prevention flag
+      await remote.handleRemoteMessage(
+        JSON.stringify({
+          seq: 1,
+          method: 'deliver',
+          params: ['bringOutYourDead'],
+        }),
+      );
+
+      // Peer restarts — flag should be cleared
+      remote.handlePeerRestart();
+
+      // Next deliverBringOutYourDead should send BOYD (not suppress it)
+      await remote.deliverBringOutYourDead();
+      expect(mockRemoteComms.sendRemoteMessage).toHaveBeenCalledWith(
+        mockRemotePeerId,
+        expect.any(String),
+      );
+    });
   });
 });

packages/ocap-kernel/src/remotes/kernel/RemoteHandle.ts

@@ -1089,11 +1089,12 @@ export class RemoteHandle implements EndpointHandle {
     // Reject pending URL redemptions - the remote won't have context for them
     this.rejectPendingRedemptions('Remote peer restarted');
 
-    // Reset sequence numbers for fresh start
+    // Reset sequence numbers and flags for fresh start
     this.#nextSendSeq = 0;
     this.#highestReceivedSeq = 0;
     this.#startSeq = 0;
     this.#retryCount = 0;
+    this.#remoteGcRequested = false;
 
     // Clear persisted sequence state
     this.#kernelStore.clearRemoteSeqState(this.remoteId);

packages/ocap-kernel/src/remotes/kernel/RemoteManager.test.ts

@@ -520,6 +520,53 @@ describe('RemoteManager', () => {
     });
   });
 
+  describe('reapRemotes', () => {
+    beforeEach(async () => {
+      const messageHandler = vi.fn();
+      vi.mocked(remoteComms.initRemoteComms).mockResolvedValue(mockRemoteComms);
+      remoteManager.setMessageHandler(messageHandler);
+      await remoteManager.initRemoteComms();
+    });
+
+    it('schedules reap for all remotes when no filter provided', () => {
+      remoteManager.establishRemote('peer1');
+      remoteManager.establishRemote('peer2');
+      remoteManager.establishRemote('peer3');
+
+      remoteManager.reapRemotes();
+
+      // Drain the reap queue and verify all remotes were scheduled
+      const reaped: string[] = [];
+      let action = kernelStore.nextReapAction();
+      while (action) {
+        reaped.push(action.endpointId);
+        action = kernelStore.nextReapAction();
+      }
+      expect(reaped).toStrictEqual(['r1', 'r2', 'r3']);
+    });
+
+    it('schedules reap only for remotes matching the filter', () => {
+      remoteManager.establishRemote('peer1');
+      remoteManager.establishRemote('peer2');
+      remoteManager.establishRemote('peer3');
+
+      remoteManager.reapRemotes((remoteId) => remoteId === 'r2');
+
+      const action = kernelStore.nextReapAction();
+      expect(action).toStrictEqual({
+        type: 'bringOutYourDead',
+        endpointId: 'r2',
+      });
+      expect(kernelStore.nextReapAction()).toBeUndefined();
+    });
+
+    it('does nothing when no remotes exist', () => {
+      remoteManager.reapRemotes();
+
+      expect(kernelStore.nextReapAction()).toBeUndefined();
+    });
+  });
+
   describe('handleRemoteGiveUp', () => {
     beforeEach(async () => {
       const messageHandler = vi.fn();

packages/ocap-kernel/src/remotes/kernel/RemoteManager.ts

@@ -351,6 +351,20 @@ export class RemoteManager {
     await this.#platformServices.closeConnection(peerId);
   }
 
+  /**
+   * Schedule reap for remotes that match the filter.
+   * This is for debugging and testing purposes only.
+   *
+   * @param filter - A function that returns true if the remote should be reaped.
+   */
+  reapRemotes(filter: (remoteId: RemoteId) => boolean = () => true): void {
+    for (const remoteId of this.#remotes.keys()) {
+      if (filter(remoteId)) {
+        this.#kernelStore.scheduleReap(remoteId);
+      }
+    }
+  }
+
   /**
    * Take note of where a peer might be.
    *