feat(cloud-agent-next): coalesce adjacent part deltas in outbox

services/cloud-agent-next/src/sandbox-control/diagnostics.test.ts

@@ -71,6 +71,27 @@ describe('logControlDiagnostic', () => {
     });
     expect(withFields).toHaveBeenCalledTimes(1);
   });
+
+  it('suppresses applied delta progress but logs a rejected delta session event', () => {
+    logControlDiagnostic(
+      'session_event_result',
+      { eventType: 'message.part.delta', applied: true },
+      'info'
+    );
+    expect(withFields).not.toHaveBeenCalled();
+
+    logControlDiagnostic(
+      'session_event_result',
+      { eventType: 'message.part.delta', applied: false },
+      'info'
+    );
+    expect(withFields).toHaveBeenCalledTimes(1);
+    expect(withFields.mock.calls[0]?.[0]).toMatchObject({
+      diagnosticEvent: 'session_event_result',
+      eventType: 'message.part.delta',
+      applied: false,
+    });
+  });
 });
 
 describe('diagnosticCause', () => {

services/cloud-agent-next/src/sandbox-control/session-forwarding.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import { SANDBOX_CONTROL_FORWARD_OPERATION_LIMIT } from '../shared/sandbox-control-protocol.js';
 import { createSessionForwarding } from './session-forwarding.js';
 
 describe('createSessionForwarding', () => {
@@ -118,6 +119,41 @@ describe('createSessionForwarding', () => {
     expect(forwarding.stats()).toMatchObject({ waiting: 0, inFlight: 0, bufferedBytes: 0 });
   });
 
+  it('admits up to the forward operation limit and rejects beyond it', async () => {
+    const forwarding = createSessionForwarding();
+    const release = Promise.withResolvers<void>();
+    const admitted: Array<Promise<unknown>> = [];
+    for (let index = 0; index < SANDBOX_CONTROL_FORWARD_OPERATION_LIMIT; index++) {
+      admitted.push(
+        forwarding.enqueueFenced({
+          sessionId: 'workspace_1',
+          bytes: 1,
+          deadlineAt: Date.now() + 60_000,
+          fence: async () => true,
+          forward: async () => release.promise,
+        })
+      );
+    }
+    expect(forwarding.stats()).toMatchObject({
+      waiting: SANDBOX_CONTROL_FORWARD_OPERATION_LIMIT,
+      inFlight: 0,
+    });
+
+    await expect(
+      forwarding.enqueueFenced({
+        sessionId: 'workspace_1',
+        bytes: 1,
+        deadlineAt: Date.now() + 60_000,
+        fence: async () => true,
+        forward: async () => 'unreachable',
+      })
+    ).rejects.toMatchObject({ retryable: true });
+
+    release.resolve();
+    await Promise.allSettled(admitted);
+    expect(forwarding.stats()).toMatchObject({ waiting: 0, inFlight: 0, bufferedBytes: 0 });
+  });
+
   it('keeps a detached lane until admitted work settles', async () => {
     const forwarding = createSessionForwarding();
     const release = Promise.withResolvers<void>();

services/cloud-agent-next/src/sandbox-control/session-forwarding.ts

@@ -1,6 +1,6 @@
 import {
   MAX_SANDBOX_CONTROL_FRAME_BYTES,
-  SANDBOX_CONTROL_OPERATION_LIMIT,
+  SANDBOX_CONTROL_FORWARD_OPERATION_LIMIT,
 } from '../shared/sandbox-control-protocol.js';
 
 const MAX_SESSION_FORWARD_BYTES = 4 * MAX_SANDBOX_CONTROL_FRAME_BYTES;
@@ -88,7 +88,7 @@ export function createSessionForwarding(): SessionForwarding {
       if (input.bytes > MAX_SANDBOX_CONTROL_FRAME_BYTES)
         return Promise.reject(new SessionForwardingError('Forwarded frame is too large', false));
       if (
-        stats.waiting + stats.inFlight >= SANDBOX_CONTROL_OPERATION_LIMIT ||
+        stats.waiting + stats.inFlight >= SANDBOX_CONTROL_FORWARD_OPERATION_LIMIT ||
         stats.bufferedBytes + input.bytes > MAX_SESSION_FORWARD_BYTES
       )
         return Promise.reject(

services/cloud-agent-next/src/sandbox-session/SandboxSession.ts

@@ -644,7 +644,8 @@ export class SandboxSession extends DurableObject<Env> {
     if (input.payload.type === 'session.created' || input.payload.type === 'session.updated') {
       const info = input.payload.properties.info;
       if (typeof info === 'object' && info !== null) {
-        if ('id' in info && info.id !== eventKiloSessionId) return { applied: false };
+        if ('id' in info && info.id !== eventKiloSessionId)
+          return result(false, 'session_id_mismatch');
         if (eventKiloSessionId !== root && ('parentID' in info || 'directory' in info)) {
           const directory = this.directory(metadata);
           const child = childSessionLineage(info, directory);
@@ -653,7 +654,7 @@ export class SandboxSession extends DurableObject<Env> {
             child.sessionId !== eventKiloSessionId ||
             input.identity.directory !== directory
           )
-            return { applied: false };
+            return result(false, 'child_lineage_mismatch');
         }
       }
     }
@@ -949,12 +950,7 @@ export class SandboxSession extends DurableObject<Env> {
     wrapperInstanceId?: string;
   }): Promise<SandboxEventBatchResult> {
     const outcomes: SandboxEventBatchItemOutcome[] = [];
-    let halted = false;
-    for (const item of input.items) {
-      if (halted) {
-        outcomes.push({ receiptId: item.receiptId, status: 'unattempted' });
-        continue;
-      }
+    for (const [index, item] of input.items.entries()) {
       try {
         let applied = false;
         let retryable: boolean | undefined;
@@ -990,7 +986,28 @@ export class SandboxSession extends DurableObject<Env> {
         );
       } catch {
         outcomes.push({ receiptId: item.receiptId, status: 'unknown' });
-        halted = true;
+        try {
+          logControlDiagnostic(
+            'session_event_batch_item_failed',
+            {
+              sessionId: this.sessionId,
+              wrapperInstanceId: input.wrapperInstanceId,
+              receiptId: item.receiptId,
+              sequence: item.sequence,
+              eventFamily: item.event,
+              eventType:
+                item.event === 'session.event'
+                  ? diagnosticEventType(item.payload.type)
+                  : 'session.preparing',
+              eventIndex: index,
+              batchSize: input.items.length,
+              disposition: 'application_exception',
+            },
+            'warn'
+          );
+        } catch {
+          // Containment only: a diagnostic must never replace or alter the batch result.
+        }
       }
     }
     return { outcomes };