test(kernel-errors): add missing error code assertions

- Add ENDPOINT_UNREACHABLE and DELIVERY_FAILED test cases to
  KernelRouter tests
- Tighten OBJECT_DELETED and BAD_PROMISE_RESOLUTION assertions from
  expect.anything() to check for specific error codes
- Verify CONNECTION_LOST in handleRemoteGiveUp rejection payload
- Verify PEER_RESTARTED in handleIncarnationChange rejection payload

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: rekmarks

packages/ocap-kernel/src/KernelRouter.test.ts

@@ -243,11 +243,18 @@ describe('KernelRouter', () => {
           'kp1',
           'deliver|splat|result',
         );
-        // Verify the promise was rejected with 'no vat'
+        // Verify the promise was rejected with OBJECT_DELETED
         expect(kernelQueue.resolvePromises).toHaveBeenCalledWith(
           undefined,
           expect.arrayContaining([
-            expect.arrayContaining(['kp1', true, expect.anything()]),
+            expect.arrayContaining([
+              'kp1',
+              true,
+              expect.objectContaining({
+                body: expect.stringContaining('[KERNEL:OBJECT_DELETED]'),
+                slots: [],
+              }),
+            ]),
           ]),
         );
       });
@@ -319,11 +326,19 @@ describe('KernelRouter', () => {
         expect(endpointHandle.deliverMessage).not.toHaveBeenCalled();
         expect(result).toBeUndefined();
 
-        // Verify the result promise was rejected
+        // Verify the result promise was rejected with BAD_PROMISE_RESOLUTION
         expect(kernelQueue.resolvePromises).toHaveBeenCalledWith(
           undefined,
           expect.arrayContaining([
-            expect.arrayContaining(['kp2', true, expect.anything()]),
+            expect.arrayContaining([
+              'kp2',
+              true,
+              expect.objectContaining({
+                body: expect.stringContaining(
+                  '[KERNEL:BAD_PROMISE_RESOLUTION]',
+                ),
+              }),
+            ]),
           ]),
         );
       });
@@ -369,6 +384,83 @@ describe('KernelRouter', () => {
           ]),
         );
       });
+
+      it('splats message with ENDPOINT_UNREACHABLE when endpoint vanishes', async () => {
+        const endpointId = 'v1';
+        const target = 'ko123';
+        (kernelStore.getOwner as unknown as MockInstance).mockReturnValueOnce(
+          endpointId,
+        );
+        // getEndpoint throws (endpoint gone)
+        (getEndpoint as unknown as MockInstance).mockImplementationOnce(() => {
+          throw new Error('vat not found');
+        });
+        (
+          kernelStore.getKernelPromise as unknown as MockInstance
+        ).mockReturnValueOnce({ decider: endpointId });
+
+        const message: Message = {
+          methargs: { body: 'method args', slots: [] },
+          result: 'kp1',
+        };
+        const sendItem: RunQueueItemSend = {
+          type: 'send',
+          target,
+          message: message as unknown as SwingsetMessage,
+        };
+
+        const result = await kernelRouter.deliver(sendItem);
+
+        expect(result).toBeUndefined();
+        expect(kernelQueue.resolvePromises).toHaveBeenCalledWith(
+          endpointId,
+          expect.arrayContaining([
+            expect.arrayContaining([
+              'kp1',
+              true,
+              expect.objectContaining({
+                body: expect.stringContaining('[KERNEL:ENDPOINT_UNREACHABLE]'),
+              }),
+            ]),
+          ]),
+        );
+      });
+
+      it('rejects with DELIVERY_FAILED when endpoint.deliverMessage throws', async () => {
+        const endpointId = 'v1';
+        const target = 'ko123';
+        (kernelStore.getOwner as unknown as MockInstance).mockReturnValueOnce(
+          endpointId,
+        );
+        (
+          endpointHandle.deliverMessage as unknown as MockInstance
+        ).mockRejectedValueOnce(new Error('queue full'));
+
+        const message: Message = {
+          methargs: { body: 'method args', slots: [] },
+          result: 'kp1',
+        };
+        const sendItem: RunQueueItemSend = {
+          type: 'send',
+          target,
+          message: message as unknown as SwingsetMessage,
+        };
+
+        await kernelRouter.deliver(sendItem);
+
+        expect(kernelQueue.resolvePromises).toHaveBeenCalledWith(
+          endpointId,
+          expect.arrayContaining([
+            expect.arrayContaining([
+              'kp1',
+              true,
+              expect.objectContaining({
+                body: expect.stringContaining('[KERNEL:DELIVERY_FAILED]'),
+              }),
+            ]),
+          ]),
+        );
+      });
     });
 
     describe('notify', () => {

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

@@ -771,12 +771,31 @@ describe('RemoteManager', () => {
       expect(() => onRemoteGiveUp(peerId)).not.toThrow();
     });
 
-    it('handles remote give up and processes promises when they exist', () => {
+    it('rejects kernel promises with CONNECTION_LOST when remote has promises', () => {
       const peerId = 'peer-with-promises';
-      remoteManager.establishRemote(peerId);
+      const remote = remoteManager.establishRemote(peerId);
+      const { remoteId } = remote;
+
+      // Set up a promise where the remote is the decider
+      const [kpid] = kernelStore.initKernelPromise();
+      kernelStore.setPromiseDecider(kpid, remoteId);
+      kernelKVStore.set(`cle.${remoteId}.p+1`, kpid);
+
+      const resolvePromisesSpy = vi.spyOn(mockKernelQueue, 'resolvePromises');
+
       const initCall = vi.mocked(remoteComms.initRemoteComms).mock.calls[0];
       const onRemoteGiveUp = initCall?.[6] as (peerId: string) => void;
-      expect(() => onRemoteGiveUp(peerId)).not.toThrow();
+      onRemoteGiveUp(peerId);
+
+      expect(resolvePromisesSpy).toHaveBeenCalledWith(remoteId, [
+        [
+          kpid,
+          true,
+          expect.objectContaining({
+            body: expect.stringContaining('[KERNEL:CONNECTION_LOST]'),
+          }),
+        ],
+      ]);
     });
 
     it('handles remote give up with no promises', () => {
@@ -829,9 +848,15 @@ describe('RemoteManager', () => {
       const onIncarnationChange = initCall?.[8] as (peerId: string) => void;
       onIncarnationChange(peerId);
 
-      // Should reject the promise with incarnation change error
+      // Should reject the promise with PEER_RESTARTED error
       expect(resolvePromisesSpy).toHaveBeenCalledWith(remoteId, [
-        [kpid, true, expect.objectContaining({ body: expect.any(String) })],
+        [
+          kpid,
+          true,
+          expect.objectContaining({
+            body: expect.stringContaining('[KERNEL:PEER_RESTARTED]'),
+          }),
+        ],
       ]);
     });