borgmcp-shared 0.7.0 → 0.7.1

package/src/conformance/adapter.ts

@@ -4,6 +4,7 @@ import {
   createProtocolEnvelope,
   decodeAssociateRepositoryCubeResponseEnvelope,
   decodeCreateCubeResponseEnvelope,
+  decodeDeleteCubeResponseEnvelope,
   decodeAppendLogResultEnvelope,
   decodeDecisionResultEnvelope,
   decodeDecisionsResultEnvelope,
@@ -130,6 +131,20 @@ export interface ConformanceCreatedCubeState {
   default_worker_role_matches: boolean;
 }
 
+export interface ConformanceDeletedCubeState {
+  readonly cube_exists: boolean;
+  readonly role_count: number;
+  readonly drone_count: number;
+  readonly log_count: number;
+  readonly claim_count: number;
+  readonly decision_count: number;
+  readonly grant_count: number;
+  readonly cube_create_binding_count: number;
+  readonly repository_association_count: number;
+  readonly active_stream_count: number;
+  readonly terminal_credential_count: number;
+}
+
 export interface ConformanceRepositoryCubeFixture {
   cube_id: string;
   name: string;
@@ -168,6 +183,8 @@ export interface ConformanceStreamResponse extends ConformanceHttpResponse {
  */
 export interface ConformanceAdmin {
   reset(): Promise<void>;
+  /** Restarts the authority while preserving durable state. */
+  restartAuthority(): Promise<void>;
   createPrincipal(name: string): Promise<ConformancePrincipal>;
   createCube(name: string): Promise<ConformanceCube>;
   /** Grants the requested cube authority; omitted access defaults to manage. */
@@ -205,6 +222,7 @@ export interface ConformanceAdmin {
     creator: ConformancePrincipal,
     response: CreateCubeResponse,
   ): Promise<ConformanceCreatedCubeState>;
+  inspectDeletedCube(cube: ConformanceCube): Promise<ConformanceDeletedCubeState>;
   prepareRepositoryCube(
     cube: ConformanceCube,
     input: {
@@ -227,6 +245,11 @@ export interface ConformanceOperations {
   protocol(credential: string | null): Promise<ConformanceHttpResponse>;
   enroll(request: unknown): Promise<ConformanceHttpResponse>;
   createCube(credential: string | null, request: unknown): Promise<ConformanceHttpResponse>;
+  deleteCube(
+    credential: string,
+    cube: ConformanceCube,
+    request: unknown,
+  ): Promise<ConformanceHttpResponse>;
   resolveRepositoryCube(credential: string | null, request: unknown): Promise<ConformanceHttpResponse>;
   associateRepositoryCube(credential: string | null, request: unknown): Promise<ConformanceHttpResponse>;
   attach(credential: string, request: unknown): Promise<ConformanceHttpResponse>;
@@ -337,6 +360,7 @@ export const ADAPTER_CONFORMANCE_FIXTURES = [
   { id: 'security.metadata-noninterference', area: 'security' },
   { id: 'security.metadata-secret-non-echo', area: 'security' },
   { id: 'security.active-stream-revocation', area: 'security' },
+  { id: 'cubes.delete-terminal-cascade', area: 'cubes' },
 ] as const;
 
 export type AdapterConformanceFixtureId =
@@ -2431,6 +2455,276 @@ export async function runAdapterConformance(
     return { stream_terminated: true, subsequent_status: 401, subsequent_code: ErrorCode.SESSION_REVOKED };
   });
 
+  await record('cubes.delete-terminal-cascade', async () => {
+    const enrollParent = async (
+      name: string,
+      marker: string,
+      retrySuffix: string,
+    ): Promise<{ principal: ConformancePrincipal; credential: string }> => {
+      const principal = await environment.admin.createPrincipal(name);
+      const invitation = await environment.admin.issueSingleUseInvitation(principal, 'client');
+      const credential = `${marker.repeat(41)}AQ`;
+      expectStatus(await environment.operations.enroll(createProtocolEnvelope(
+        `delete-${name}-enroll`,
+        {
+          invitation,
+          retry_key: `00000000-0000-4000-8000-${retrySuffix.padStart(12, '0')}`,
+          client_credential: credential,
+          client_name: name,
+        },
+      )), 201, `${name} enrollment`);
+      return { principal, credential };
+    };
+    const creator = await enrollParent('delete-creator', 'C', '701');
+    const manager = await enrollParent('delete-manager', 'M', '702');
+    const reader = await enrollParent('delete-reader', 'R', '703');
+    const writer = await enrollParent('delete-writer', 'W', '704');
+    const outsider = await enrollParent('delete-outsider', 'O', '705');
+    await environment.admin.grantCreateCubeCapability(creator.principal);
+    const createResponse = await environment.operations.createCube(
+      creator.credential,
+      createProtocolEnvelope('delete-cube-create', {
+        retry_key: '00000000-0000-4000-8000-000000000706',
+        name: 'Disposable Cube',
+        working_repo_name: 'disposable-cube',
+        repository: { kind: 'local', value: '00000000-0000-4000-8000-000000000707' },
+        template: 'default',
+      }),
+    );
+    expectStatus(createResponse, 201, 'Disposable cube creation');
+    const created = decodeCreateCubeResponseEnvelope(createResponse.body).payload;
+    const cube = { id: created.cube_id };
+    const role = { id: created.default_worker_role_id };
+    await environment.admin.grantCube(manager.principal, cube, 'manage');
+    await environment.admin.grantCube(reader.principal, cube, 'read');
+    await environment.admin.grantCube(writer.principal, cube, 'write');
+    const drone = await environment.admin.createDrone(creator.principal, cube, role);
+    const droneCredential = await environment.admin.issueManagedDroneSession(drone);
+    const append = await environment.operations.append(
+      creator.credential,
+      cube,
+      createProtocolEnvelope('delete-log', { message: 'deleted with cube' }),
+    );
+    expectStatus(append, 201, 'Deletion fixture log');
+    const entry = decodeAppendLogResultEnvelope(append.body).payload.entry;
+    expectStatus(await environment.operations.ack(
+      creator.credential,
+      cube,
+      createProtocolEnvelope('delete-claim', { entry_id: entry.id, kind: 'claim' }),
+    ), 204, 'Deletion fixture claim');
+    expectStatus(await environment.operations.recordDecision(
+      manager.credential,
+      cube,
+      createProtocolEnvelope('delete-decision', { topic: 'cleanup', decision: 'delete' }),
+    ), 201, 'Deletion fixture decision');
+
+    const beforeDenied = await environment.admin.inspectCubeManagementState(cube);
+    for (const [kind, credential] of [
+      ['read', reader.credential],
+      ['write', writer.credential],
+      ['drone-session', droneCredential],
+    ] as const) {
+      expectError(
+        await environment.operations.deleteCube(
+          credential,
+          cube,
+          createProtocolEnvelope(`delete-${kind}-denied`, {}),
+        ),
+        403,
+        ErrorCode.ACCESS_DENIED,
+        `${kind} cube deletion`,
+      );
+      invariant(
+        same(await environment.admin.inspectCubeManagementState(cube), beforeDenied),
+        `${kind} cube deletion denial mutated the cube.`,
+      );
+    }
+    expectError(
+      await environment.operations.deleteCube(
+        outsider.credential,
+        cube,
+        createProtocolEnvelope('delete-outsider-denied', {}),
+      ),
+      404,
+      ErrorCode.NOT_FOUND,
+      'Never-authorized cube deletion',
+    );
+
+    const parentStream = await environment.operations.openStream(manager.credential, cube, null);
+    const droneStream = await environment.operations.openStream(droneCredential, cube, null);
+    expectStatus(parentStream, 200, 'Deletion parent stream');
+    expectStatus(droneStream, 200, 'Deletion drone stream');
+    invariant(parentStream.stream && droneStream.stream, 'Deletion fixture streams did not open.');
+    const parentEvents = new SseEventReader(parentStream.stream);
+    const droneEvents = new SseEventReader(droneStream.stream);
+    for (const streamReader of [parentEvents, droneEvents]) {
+      invariant((await streamReader.next()).type === 'log', 'Deletion stream omitted replay log.');
+      const bookmark = await streamReader.next();
+      invariant(bookmark.type === 'bookmark' && bookmark.replay_complete, 'Deletion stream omitted bookmark.');
+    }
+    const parentTerminal = parentEvents.next();
+    const droneTerminal = droneEvents.next();
+    await provePending(parentTerminal, 'Parent deletion terminal event', pendingProbeMs);
+    await provePending(droneTerminal, 'Drone deletion terminal event', pendingProbeMs);
+
+    const deleted = await environment.operations.deleteCube(
+      manager.credential,
+      cube,
+      createProtocolEnvelope('delete-managed-cube', {}),
+    );
+    expectStatus(deleted, 200, 'Managed cube deletion');
+    invariant(
+      same(decodeDeleteCubeResponseEnvelope(deleted.body).payload, {
+        cube_id: cube.id,
+        deleted: true,
+      }),
+      'Cube deletion response did not identify the terminal cube.',
+    );
+    for (const [kind, event] of [
+      ['parent', await within(parentTerminal, 'Parent deletion terminal event', streamDeadlineMs)],
+      ['drone', await within(droneTerminal, 'Drone deletion terminal event', streamDeadlineMs)],
+    ] as const) {
+      invariant(
+        event.type === 'error' && event.error.error.code === ErrorCode.CUBE_DELETED,
+        `${kind} stream did not receive CUBE_DELETED.`,
+      );
+    }
+    for (const streamReader of [parentEvents, droneEvents]) {
+      let closed = false;
+      try {
+        await within(streamReader.next(), 'Deleted cube stream close', streamDeadlineMs);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes('did not settle')) throw error;
+        closed = true;
+      }
+      invariant(closed, 'Deleted cube stream yielded after its terminal error.');
+      await streamReader.close();
+    }
+
+    invariant(
+      same(await environment.admin.inspectDeletedCube(cube), {
+        cube_exists: false,
+        role_count: 0,
+        drone_count: 0,
+        log_count: 0,
+        claim_count: 0,
+        decision_count: 0,
+        grant_count: 0,
+        cube_create_binding_count: 0,
+        repository_association_count: 0,
+        active_stream_count: 0,
+        terminal_credential_count: 5,
+      }),
+      'Cube deletion did not atomically remove cube-owned state and preserve only terminal credentials.',
+    );
+    for (const [kind, credential] of [
+      ['creator', creator.credential],
+      ['manager', manager.credential],
+      ['reader', reader.credential],
+      ['writer', writer.credential],
+      ['drone', droneCredential],
+    ] as const) {
+      expectError(
+        await environment.operations.read(
+          credential,
+          cube,
+          createProtocolEnvelope(`delete-${kind}-terminal`, { cursor: null, limit: 1 }),
+        ),
+        PROTOCOL_HTTP_CONTRACT.cube_deleted_status,
+        ErrorCode.CUBE_DELETED,
+        `${kind} post-delete request`,
+      );
+      expectError(
+        await environment.operations.deleteCube(
+          credential,
+          cube,
+          createProtocolEnvelope(`delete-${kind}-repeat-terminal`, {}),
+        ),
+        PROTOCOL_HTTP_CONTRACT.cube_deleted_status,
+        ErrorCode.CUBE_DELETED,
+        `${kind} post-delete DELETE`,
+      );
+    }
+    expectError(
+      await environment.operations.deleteCube(
+        outsider.credential,
+        cube,
+        createProtocolEnvelope('delete-outsider-hidden-repeat', {}),
+      ),
+      404,
+      ErrorCode.NOT_FOUND,
+      'Never-authorized post-delete DELETE',
+    );
+    expectError(
+      await environment.operations.read(
+        outsider.credential,
+        cube,
+        createProtocolEnvelope('delete-outsider-hidden', { cursor: null, limit: 1 }),
+      ),
+      404,
+      ErrorCode.NOT_FOUND,
+      'Never-authorized post-delete request',
+    );
+    await environment.admin.restartAuthority();
+    for (const [kind, credential] of [
+      ['creator', creator.credential],
+      ['manager', manager.credential],
+      ['reader', reader.credential],
+      ['writer', writer.credential],
+      ['drone', droneCredential],
+    ] as const) {
+      expectError(
+        await environment.operations.read(
+          credential,
+          cube,
+          createProtocolEnvelope(`delete-${kind}-after-restart`, { cursor: null, limit: 1 }),
+        ),
+        PROTOCOL_HTTP_CONTRACT.cube_deleted_status,
+        ErrorCode.CUBE_DELETED,
+        `${kind} post-restart deleted-cube request`,
+      );
+      expectError(
+        await environment.operations.deleteCube(
+          credential,
+          cube,
+          createProtocolEnvelope(`delete-${kind}-repeat-after-restart`, {}),
+        ),
+        PROTOCOL_HTTP_CONTRACT.cube_deleted_status,
+        ErrorCode.CUBE_DELETED,
+        `${kind} post-restart DELETE`,
+      );
+    }
+    expectError(
+      await environment.operations.deleteCube(
+        outsider.credential,
+        cube,
+        createProtocolEnvelope('delete-outsider-hidden-repeat-after-restart', {}),
+      ),
+      404,
+      ErrorCode.NOT_FOUND,
+      'Never-authorized post-restart DELETE',
+    );
+    expectError(
+      await environment.operations.read(
+        outsider.credential,
+        cube,
+        createProtocolEnvelope('delete-outsider-hidden-after-restart', { cursor: null, limit: 1 }),
+      ),
+      404,
+      ErrorCode.NOT_FOUND,
+      'Never-authorized post-restart request',
+    );
+    return {
+      deletion_status: 200,
+      cascade_complete: true,
+      terminal_stream_error: ErrorCode.CUBE_DELETED,
+      terminal_http_status: 410,
+      terminal_state_durable_after_restart: true,
+      unknown_hidden_status: 404,
+      non_member_manager: true,
+    };
+  });
+
   const normalizedTranscript = results.map(({ id, observations }) => ({ id, observations }));
   return { ok: results.every((result) => result.ok), results, normalizedTranscript };
 }

package/src/conformance/index.ts

@@ -3,6 +3,7 @@ import type {
   AttachResponse,
   AssociateRepositoryCubeRequest,
   CreateCubeRequest,
+  DeleteCubeRequest,
   EnrollmentExchangeRequest,
   ResolveRepositoryCubeRequest,
 } from '../protocol/contract.js';
@@ -443,6 +444,58 @@ readonly CreateCubeAssociationConformanceVector[] = [
   },
 ];
 
+export interface DeleteCubeConformanceVector {
+  name: string;
+  request: DeleteCubeRequest;
+  expected: {
+    status: 200 | 403 | 404 | 410;
+    error?: 'ACCESS_DENIED' | 'NOT_FOUND' | 'CUBE_DELETED';
+    response?: { deleted: true };
+    terminal_sse?: { event: 'error'; error: 'CUBE_DELETED'; closes_after_event: true };
+    durable_after_restart?: true;
+    mutation: 'cascade' | 'none';
+  };
+}
+
+/** Cube deletion is manage-gated, cascading, terminal, and durable across authority restart. */
+export const DELETE_CUBE_CONFORMANCE: readonly DeleteCubeConformanceVector[] = [
+  {
+    name: 'non-member managing parent deletes the cube atomically',
+    request: {},
+    expected: { status: 200, response: { deleted: true }, mutation: 'cascade' },
+  },
+  {
+    name: 'known read and write grants and drone sessions cannot delete',
+    request: {},
+    expected: { status: 403, error: 'ACCESS_DENIED', mutation: 'none' },
+  },
+  {
+    name: 'never-authorized and unknown callers cannot enumerate the cube',
+    request: {},
+    expected: { status: 404, error: 'NOT_FOUND', mutation: 'none' },
+  },
+  {
+    name: 'connected clients receive one terminal error frame before close',
+    request: {},
+    expected: {
+      status: 410,
+      error: 'CUBE_DELETED',
+      terminal_sse: { event: 'error', error: 'CUBE_DELETED', closes_after_event: true },
+      mutation: 'none',
+    },
+  },
+  {
+    name: 'former authorized credentials retain the typed terminal state after restart',
+    request: {},
+    expected: {
+      status: 410,
+      error: 'CUBE_DELETED',
+      durable_after_restart: true,
+      mutation: 'none',
+    },
+  },
+];
+
 export interface ResolveRepositoryCubeConformanceVector {
   name: string;
   request: ResolveRepositoryCubeRequest;

package/src/protocol/contract.ts

@@ -13,12 +13,13 @@ import type {
 } from './types.js';
 
 export const SHARED_PACKAGE_NAME = 'borgmcp-shared' as const;
-export const SHARED_PACKAGE_VERSION = '0.7.0' as const;
+export const SHARED_PACKAGE_VERSION = '0.7.1' as const;
 
 export const HEALTH_PATH = '/healthz' as const;
 export const PROTOCOL_INFO_PATH = '/api/protocol' as const;
 export const ENROLLMENT_EXCHANGE_PATH = '/api/enrollment/exchange' as const;
 export const CUBES_PATH = '/api/cubes' as const;
+export const CUBE_PATH = '/api/cubes/:cubeId' as const;
 export const REPOSITORY_CUBE_RESOLVE_PATH = '/api/repository-cubes/resolve' as const;
 export const REPOSITORY_CUBE_ASSOCIATION_PATH = '/api/repository-cubes/association' as const;
 export const ATTACH_PATH = '/api/client/attach' as const;
@@ -29,6 +30,13 @@ export const PROTOCOL_HTTP_CONTRACT = {
   protocol: { method: 'GET', path: PROTOCOL_INFO_PATH, authenticated: false, success_status: 200 },
   enrollment: { method: 'POST', path: ENROLLMENT_EXCHANGE_PATH, authenticated: 'invitation', success_status: 201 },
   cubes: { method: 'POST', path: CUBES_PATH, authenticated: true, success_status: 201 },
+  cube_delete: {
+    method: 'DELETE',
+    path: CUBE_PATH,
+    authenticated: true,
+    success_status: 200,
+    mutation: true,
+  },
   repository_cube_resolve: {
     method: 'POST',
     path: REPOSITORY_CUBE_RESOLVE_PATH,
@@ -68,6 +76,7 @@ export const PROTOCOL_HTTP_CONTRACT = {
   session_revoked_status: 401,
   session_rejected_status: 401,
   cursor_expired_status: 410,
+  cube_deleted_status: 410,
   drone_evicted_status: 410,
   content_too_large_status: 413,
   unsupported_protocol_status: 426,
@@ -164,6 +173,13 @@ export interface CreateCubeResponse {
   access: 'manage';
 }
 
+export type DeleteCubeRequest = Record<string, never>;
+
+export interface DeleteCubeResponse {
+  cube_id: string;
+  deleted: true;
+}
+
 export interface ResolveRepositoryCubeRequest {
   working_repo_name: string;
   repository: CreateCubeRepository;
@@ -327,7 +343,7 @@ export function decodeProtocolTagPreflight(value: unknown): ProtocolTagPreflight
   exactKeys(input, ['protocol_version'], ['protocol_version']);
   if (input.protocol_version !== PROTOCOL_VERSION) {
     throw new ProtocolContractError(
-      'This client requires protocol v6. The peer presents a different version. Update `borgmcp-server` and `borgmcp` to matching releases — server first, then client.',
+      'This client requires protocol v7. The peer presents a different version. Update `borgmcp-server` and `borgmcp` to matching releases — server first, then client.',
       ErrorCode.UNSUPPORTED_PROTOCOL_VERSION,
       ['protocol_version'],
     );
@@ -596,6 +612,30 @@ export function decodeCreateCubeResponseEnvelope(value: unknown): ProtocolEnvelo
   return decodeProtocolEnvelope(value, decodeCreateCubeResponse);
 }
 
+export function decodeDeleteCubeRequest(value: unknown): DeleteCubeRequest {
+  const input = record(value);
+  exactKeys(input, [], []);
+  return {};
+}
+
+export function decodeDeleteCubeRequestEnvelope(value: unknown): ProtocolEnvelope<DeleteCubeRequest> {
+  return decodeProtocolEnvelope(value, decodeDeleteCubeRequest);
+}
+
+export function decodeDeleteCubeResponse(value: unknown): DeleteCubeResponse {
+  const input = record(value);
+  exactKeys(input, ['cube_id', 'deleted'], ['cube_id', 'deleted']);
+  if (input.deleted !== true) fail('Cube deletion result must be terminal.', ['deleted']);
+  return {
+    cube_id: decodeUuid(input.cube_id, ['cube_id']),
+    deleted: true,
+  };
+}
+
+export function decodeDeleteCubeResponseEnvelope(value: unknown): ProtocolEnvelope<DeleteCubeResponse> {
+  return decodeProtocolEnvelope(value, decodeDeleteCubeResponse);
+}
+
 export function decodeResolveRepositoryCubeRequest(value: unknown): ResolveRepositoryCubeRequest {
   const input = record(value);
   exactKeys(input, ['working_repo_name', 'repository'], ['working_repo_name', 'repository']);

package/src/protocol/errors.ts

@@ -17,6 +17,7 @@ export enum ErrorCode {
   CUBE_ALREADY_ASSOCIATED = 'CUBE_ALREADY_ASSOCIATED',
   ROLE_IN_USE = 'ROLE_IN_USE',
   ROLE_HAS_FROZEN_DRONES = 'ROLE_HAS_FROZEN_DRONES',
+  CUBE_DELETED = 'CUBE_DELETED',
   DRONE_EVICTED = 'DRONE_EVICTED',
   DRONE_FROZEN = 'DRONE_FROZEN',
   UNSUPPORTED_PROTOCOL_VERSION = 'UNSUPPORTED_PROTOCOL_VERSION',

package/src/protocol/sse.ts

@@ -2,11 +2,13 @@ import type { EnrichedStreamEntry } from './types.js';
 import {
   ProtocolContractError,
   decodeCanonicalTimestamp,
+  decodeProtocolErrorEnvelope,
   decodeLogCursor,
   decodeOpaqueIdentifier,
   decodeUuid,
   utf8ByteLength,
   type LogCursor,
+  type ProtocolErrorEnvelope,
 } from './contract.js';
 
 export const SSE_LIMITS = {
@@ -31,6 +33,7 @@ export type StreamEvent =
       actor_drone_id: string;
       occurred_at: string;
     }
+  | StreamErrorEvent
   | { type: 'heartbeat'; at: string; broadcast_hwm: LogCursor | null }
   | {
       type: 'bookmark';
@@ -41,6 +44,12 @@ export type StreamEvent =
     }
   | { type: 'unknown'; event: string; raw_data: string };
 
+/** A terminal stream failure; the server sends this frame once and then closes. */
+export interface StreamErrorEvent {
+  type: 'error';
+  error: ProtocolErrorEnvelope;
+}
+
 function object(value: unknown): Record<string, unknown> {
   if (typeof value !== 'object' || value === null || Array.isArray(value)) {
     throw new ProtocolContractError('SSE data must be a JSON object.');
@@ -124,7 +133,7 @@ export function decodeEnrichedStreamEntry(value: unknown): EnrichedStreamEntry {
 
 export function encodeSseEvent(event: Exclude<StreamEvent, { type: 'unknown' }>): string {
   const lines = [`event: ${event.type}`];
-  let data: Record<string, unknown>;
+  let data: unknown;
   if (event.type === 'log') {
     const cursor = decodeLogCursor(event.cursor);
     const entry = decodeEnrichedStreamEntry(event.entry);
@@ -142,6 +151,8 @@ export function encodeSseEvent(event: Exclude<StreamEvent, { type: 'unknown' }>)
       actor_drone_id: decodeUuid(event.actor_drone_id, ['actor_drone_id']),
       occurred_at: decodeCanonicalTimestamp(event.occurred_at, ['occurred_at']),
     };
+  } else if (event.type === 'error') {
+    data = decodeProtocolErrorEnvelope(event.error);
   } else if (event.type === 'heartbeat') {
     data = {
       at: decodeCanonicalTimestamp(event.at, ['at']),
@@ -217,7 +228,7 @@ function decodeFrame(frame: string): StreamEvent {
   if (rawDataBytes > SSE_LIMITS.data_bytes) {
     throw new ProtocolContractError('SSE data exceeds the byte limit.');
   }
-  if (!['log', 'ack', 'claim', 'heartbeat', 'bookmark'].includes(eventName)) {
+  if (!['log', 'ack', 'claim', 'error', 'heartbeat', 'bookmark'].includes(eventName)) {
     if (rawDataBytes > SSE_LIMITS.unknown_data_bytes) {
       throw new ProtocolContractError('Unknown SSE event data exceeds the byte limit.');
     }
@@ -247,6 +258,10 @@ function decodeFrame(frame: string): StreamEvent {
     throw new ProtocolContractError(`${eventName} SSE events must not carry a resume id.`);
   }
 
+  if (eventName === 'error') {
+    return { type: 'error', error: decodeProtocolErrorEnvelope(parsed) };
+  }
+
   if (eventName === 'ack' || eventName === 'claim') {
     exactKeys(data, ['log_entry_id', 'actor_drone_id', 'occurred_at'], [
       'log_entry_id',

package/src/protocol/version.ts

@@ -1,4 +1,4 @@
-/** Current Borg coordination protocol generation. Clean-slate v6. */
-export const PROTOCOL_VERSION = '6' as const;
+/** Current Borg coordination protocol generation. Clean-slate v7. */
+export const PROTOCOL_VERSION = '7' as const;
 
 export type ProtocolVersion = typeof PROTOCOL_VERSION;