borgmcp-shared 0.13.1 → 1.0.0

package/src/conformance/adapter.ts

@@ -6,6 +6,8 @@ import {
   decodeCreateCubeResponseEnvelope,
   decodeDeleteCubeResponseEnvelope,
   decodeAppendLogResultEnvelope,
+  decodeAckStatusResultEnvelope,
+  decodeEntryQueryResultEnvelope,
   decodeDecisionResultEnvelope,
   decodeDecisionsResultEnvelope,
   decodeEnrollmentExchangeResponseEnvelope,
@@ -40,6 +42,7 @@ import {
   type StreamEvent,
   type DroneRuntimeMetadata,
   type CubeDocument,
+  type EnrichedStreamEntry,
 } from '../protocol/index.js';
 import {
   APPEND_LOG_IDEMPOTENCY_CONFORMANCE,
@@ -119,6 +122,9 @@ export interface ConformanceCubeManagementState {
 export interface ConformanceAuthorityState {
   enrolled_clients: number;
   enrollment_claims: number;
+  activity_acknowledgements: number;
+  activity_claims: number;
+  activity_log_entries: number;
   cubes: number;
   roles: number;
   grants: number;
@@ -214,12 +220,7 @@ export interface ConformanceAdmin {
     readonly isDefault?: boolean;
     readonly isMandatory?: boolean;
   }): Promise<ConformanceRole>;
-  referenceRoleFromTaxonomy(cube: ConformanceCube, role: ConformanceRole): Promise<void>;
-  configureMessageClassRouting(
-    cube: ConformanceCube,
-    className: string,
-    recipientDroneIds: readonly string[],
-  ): Promise<void>;
+  replaceLogEntryId(cube: ConformanceCube, currentId: string, replacementId: string): Promise<void>;
   createDrone(
     principal: ConformancePrincipal,
     cube: ConformanceCube,
@@ -299,11 +300,21 @@ export interface ConformanceOperations {
     cube: ConformanceCube,
     request: unknown,
   ): Promise<ConformanceHttpResponse>;
+  entryQuery(
+    credential: string,
+    cube: ConformanceCube,
+    request: unknown,
+  ): Promise<ConformanceHttpResponse>;
   ack(
     credential: string,
     cube: ConformanceCube,
     request: unknown,
   ): Promise<ConformanceHttpResponse>;
+  ackStatus(
+    credential: string,
+    cube: ConformanceCube,
+    request: unknown,
+  ): Promise<ConformanceHttpResponse>;
   updateCube(
     credential: string,
     cube: ConformanceCube,
@@ -379,10 +390,13 @@ export const ADAPTER_CONFORMANCE_FIXTURES = [
   { id: 'security.oversize-request', area: 'security' },
   { id: 'security.cross-cube-isolation', area: 'security' },
   { id: 'log.append-idempotency', area: 'log' },
+  { id: 'log.mandatory-addressing', area: 'log' },
+  { id: 'log.entry-query', area: 'log' },
   { id: 'log.read-cursor-tuple', area: 'cursor' },
   { id: 'sse.replay-live-transition', area: 'sse' },
   { id: 'cursor.explicit-expiry', area: 'cursor' },
   { id: 'acks.idempotent', area: 'acks' },
+  { id: 'acks.status-query', area: 'acks' },
   { id: 'claims.durable-noncursor', area: 'claims' },
   { id: 'decisions.topic-supersession', area: 'decisions' },
   { id: 'security.drone-management-authorization', area: 'security' },
@@ -1468,6 +1482,7 @@ export async function runAdapterConformance(
       documentCube,
       createProtocolEnvelope('document-foreign-citation', {
         post_id: '00000000-0000-4000-8000-00000000031f',
+        to: 'broadcast',
         message: 'Foreign evidence must remain hidden.',
         documents: [foreignDocument.id],
       }),
@@ -1509,6 +1524,7 @@ export async function runAdapterConformance(
       documentCube,
       createProtocolEnvelope('document-citation', {
         post_id: '00000000-0000-4000-8000-000000000320',
+        to: 'broadcast',
         message: 'See the document evidence.',
         documents: [created.id, successor.id],
       }),
@@ -1521,6 +1537,7 @@ export async function runAdapterConformance(
       documentCube,
       createProtocolEnvelope('document-citation-conflict', {
         post_id: '00000000-0000-4000-8000-000000000320',
+        to: 'broadcast',
         message: 'See the document evidence.',
         documents: [successor.id],
       }),
@@ -1628,14 +1645,14 @@ export async function runAdapterConformance(
       documentCredential,
       documentCube,
       createProtocolEnvelope('document-unknown-citation', {
-        post_id: '00000000-0000-4000-8000-000000000321', message: 'Unknown.', documents: ['unknown_full_id'],
+        post_id: '00000000-0000-4000-8000-000000000321', message: 'Unknown.', to: 'broadcast', documents: ['unknown_full_id'],
       }),
     ), 404, ErrorCode.DOCUMENT_NOT_FOUND, 'Unknown document citation');
     const longAccepted = await environment.operations.append(
       documentCredential,
       documentCube,
       createProtocolEnvelope('document-advisory', {
-        post_id: '00000000-0000-4000-8000-000000000322', message: 'x'.repeat(1025),
+        post_id: '00000000-0000-4000-8000-000000000322', message: 'x'.repeat(1025), to: 'broadcast',
       }),
     );
     expectStatus(longAccepted, 201, 'Advisory log append');
@@ -1644,7 +1661,7 @@ export async function runAdapterConformance(
       documentCredential,
       documentCube,
       createProtocolEnvelope('document-hard-cap', {
-        post_id: '00000000-0000-4000-8000-000000000323', message: 'x'.repeat(4097),
+        post_id: '00000000-0000-4000-8000-000000000323', message: 'x'.repeat(4097), to: 'broadcast',
       }),
     ), 413, ErrorCode.CONTENT_TOO_LARGE, 'Hard-cap log append');
     const citedRead = decodeReadLogResultEnvelope((await environment.operations.read(
@@ -1671,6 +1688,7 @@ export async function runAdapterConformance(
     const injectedBody = JSON.stringify(
       createProtocolEnvelope('inject-b1', {
         post_id: '00000000-0000-4000-8000-000000000301',
+        to: 'broadcast',
         message: injectedMessage,
       }),
     );
@@ -1693,6 +1711,7 @@ export async function runAdapterConformance(
       cubeB,
       createProtocolEnvelope('inject-b2', {
         post_id: '00000000-0000-4000-8000-000000000302',
+        to: 'broadcast',
         message: 'post-injection-sentinel',
       }),
     );
@@ -1743,6 +1762,7 @@ export async function runAdapterConformance(
     const baseBody = JSON.stringify(
       createProtocolEnvelope('oversize-a1', {
         post_id: '00000000-0000-4000-8000-000000000303',
+        to: 'broadcast',
         message: 'must-not-persist',
       }),
     );
@@ -1775,6 +1795,7 @@ export async function runAdapterConformance(
       createProtocolEnvelope('append-b1', {
         post_id: '00000000-0000-4000-8000-000000000304',
         message: 'principal-b-secret',
+        to: 'broadcast',
       }),
     );
     expectStatus(secretAppend, 201, 'Principal B append');
@@ -1801,16 +1822,12 @@ export async function runAdapterConformance(
     });
     const firstRecipient = await environment.admin.createDrone(principal, cube, role);
     const secondRecipient = await environment.admin.createDrone(principal, cube, role);
-    await environment.admin.configureMessageClassRouting(cube, 'conformance-review', [firstRecipient.id]);
-    await environment.admin.configureMessageClassRouting(cube, 'conformance-security', [firstRecipient.id]);
     const postId = '00000000-0000-4000-8000-000000000313';
     const initialPayload = {
       post_id: postId,
       message: 'once',
-      visibility: 'direct' as const,
-      recipientDroneIds: [firstRecipient.id],
+      to: [firstRecipient.id],
       class: 'review',
-      to: ['Coordinator'],
     };
     const first = await environment.operations.append(
       credential,
@@ -1821,32 +1838,12 @@ export async function runAdapterConformance(
     const firstResult = decodeAppendLogResultEnvelope(first.body).payload;
     invariant(!firstResult.deduplicated, 'Initial append was reported as deduplicated.');
     for (const [index, vector] of APPEND_LOG_IDEMPOTENCY_CONFORMANCE.entries()) {
-      const classRouting = vector.mutation === 'resolved_class_routing';
-      const vectorPostId = classRouting
-        ? '00000000-0000-4000-8000-000000000314'
-        : postId;
-      if (classRouting) {
-        const baseline = await environment.operations.append(
-          credential,
-          cube,
-          createProtocolEnvelope('append-idempotency-class-baseline', {
-            post_id: vectorPostId,
-            message: 'once',
-            class: 'conformance-review',
-          }),
-        );
-        expectStatus(baseline, 201, 'Resolved class-routing baseline');
-      }
-      const payload = classRouting ? {
-        post_id: vectorPostId,
-        message: 'once',
-        class: 'conformance-security',
-      } : {
+      const payload = {
         ...initialPayload,
         ...(vector.mutation === 'message' ? { message: 'changed' } : {}),
-        ...(vector.mutation === 'visibility' ? { visibility: 'broadcast' as const } : {}),
-        ...(vector.mutation === 'recipient_set' ? { recipientDroneIds: [secondRecipient.id] } : {}),
-        ...(vector.mutation === 'ignored_request_shape' ? { class: 'security', to: ['Security Auditor'] } : {}),
+        ...(vector.mutation === 'audience' ? { to: 'broadcast' as const } : {}),
+        ...(vector.mutation === 'recipient_set' ? { to: [secondRecipient.id] } : {}),
+        ...(vector.mutation === 'classification' ? { class: 'security' } : {}),
       };
       const response = await environment.operations.append(
         vector.actor === 'same' ? credential : otherCredential,
@@ -1874,10 +1871,207 @@ export async function runAdapterConformance(
     );
     expectStatus(read, 200, 'Idempotent append read');
     invariant(
-      decodeReadLogResultEnvelope(read.body).payload.entries.length === 3,
+      decodeReadLogResultEnvelope(read.body).payload.entries.length === 2,
       'Append collision controls persisted the wrong number of entries.',
     );
-    return { persisted_entries: 3, stable_entry: true, deduplicated: true, conflicts: 4, cross_author_created: true };
+    return { persisted_entries: 2, stable_entry: true, deduplicated: true, conflicts: 3, cross_author_created: true };
+  });
+
+  await record('log.mandatory-addressing', async () => {
+    const cube = await environment.admin.createCube('mandatory-addressing-cube');
+    await environment.admin.grantCube(principalA, cube);
+    const role = await environment.admin.createRole(cube, {
+      roleClass: 'worker',
+      isHumanSeat: false,
+      name: 'Structured Recipient',
+    });
+    const recipient = await environment.admin.createDrone(principalA, cube, role);
+    const message = 'START NOW exact slice';
+    const before = await environment.admin.observeAuthorityState();
+    expectError(
+      await environment.operations.append(
+        credentialA,
+        cube,
+        createProtocolEnvelope('mandatory-addressing-omitted', {
+          post_id: '30000000-0000-4000-8000-000000000001',
+          message,
+        }),
+      ),
+      400,
+      ErrorCode.INVALID_INPUT,
+      'Omitted mandatory addressing',
+    );
+    assertStateDelta(before, await environment.admin.observeAuthorityState(), {}, 'Mandatory-addressing refusal');
+
+    const broadcast = await environment.operations.append(
+      credentialA,
+      cube,
+      createProtocolEnvelope('mandatory-addressing-broadcast', {
+        post_id: '30000000-0000-4000-8000-000000000002',
+        message,
+        to: 'broadcast',
+      }),
+    );
+    expectStatus(broadcast, 201, 'Explicit broadcast addressing');
+    const broadcastResult = decodeAppendLogResultEnvelope(broadcast.body).payload;
+    invariant(broadcastResult.entry.visibility === 'broadcast', 'Scalar broadcast did not produce broadcast visibility.');
+    invariant(
+      (broadcastResult.entry.recipient_drone_ids?.length ?? 0) === 0,
+      'Scalar broadcast unexpectedly resolved direct recipients.',
+    );
+    const directed = await environment.operations.append(
+      credentialA,
+      cube,
+      createProtocolEnvelope('mandatory-addressing-directed', {
+        post_id: '30000000-0000-4000-8000-000000000003',
+        message,
+        to: [recipient.id],
+        class: 'cube-wide',
+      }),
+    );
+    expectStatus(directed, 201, 'Recipient-selector union branch');
+    const directedResult = decodeAppendLogResultEnvelope(directed.body).payload;
+    invariant(directedResult.entry.visibility === 'direct', 'Explicit recipient selectors did not produce direct visibility.');
+    invariant(
+      directedResult.entry.recipient_drone_ids?.includes(recipient.id) === true,
+      'Explicit recipient selectors did not resolve the named recipient.',
+    );
+    invariant(
+      directedResult.entry.recipient_drone_ids?.length === 1,
+      'Classification changed or fell open the explicit recipient set.',
+    );
+    return { refused_status: 400, code: ErrorCode.INVALID_INPUT, persisted: false, broadcast: true, union: true, no_fall_open: true };
+  });
+
+  await record('log.entry-query', async () => {
+    const cube = await environment.admin.createCube('entry-query-cube');
+    await environment.admin.grantCube(principalA, cube);
+    const role = await environment.admin.createRole(cube, {
+      roleClass: 'worker',
+      isHumanSeat: false,
+      name: 'Entry Query Worker',
+    });
+    const acknowledgedRecipient = await environment.admin.createDrone(principalA, cube, role);
+    const claimingRecipient = await environment.admin.createDrone(principalA, cube, role);
+    const acknowledgedCredential = await environment.admin.issueManagedDroneSession(acknowledgedRecipient);
+    const claimingCredential = await environment.admin.issueManagedDroneSession(claimingRecipient);
+    const ids = [
+      '11111111-0000-4000-8000-000000000001',
+      '22222222-0000-4000-8000-000000000001',
+      '22222222-0000-4000-8000-000000000002',
+    ];
+    const entries: EnrichedStreamEntry[] = [];
+    for (const [index, id] of ids.entries()) {
+      const response = await environment.operations.append(
+        credentialA,
+        cube,
+        createProtocolEnvelope(`entry-query-append-${index}`, {
+          post_id: `40000000-0000-4000-8000-00000000000${index}`,
+          to: [acknowledgedRecipient.id, claimingRecipient.id],
+          message: `entry-query-${index}`,
+        }),
+      );
+      expectStatus(response, 201, `Entry-query fixture append ${index}`);
+      const entry = decodeAppendLogResultEnvelope(response.body).payload.entry;
+      await environment.admin.replaceLogEntryId(cube, entry.id, id);
+      entries.push({ ...entry, id });
+    }
+
+    expectStatus(
+      await environment.operations.ack(
+        acknowledgedCredential,
+        cube,
+        createProtocolEnvelope('entry-query-seed-ack', { entry_id: ids[0], kind: 'ack' }),
+      ),
+      204,
+      'Entry-query acknowledgement seed',
+    );
+    expectStatus(
+      await environment.operations.ack(
+        claimingCredential,
+        cube,
+        createProtocolEnvelope('entry-query-seed-claim', { entry_id: ids[1], kind: 'claim' }),
+      ),
+      204,
+      'Entry-query claim seed',
+    );
+
+    const before = await environment.admin.observeAuthorityState();
+    for (const [requestId, selector, expectedId] of [
+      ['entry-query-full', ids[1], ids[1]],
+      ['entry-query-prefix', '11111111', ids[0]],
+    ] as const) {
+      const response = await environment.operations.entryQuery(
+        credentialA,
+        cube,
+        createProtocolEnvelope(requestId, { entry_id: selector }),
+      );
+      expectStatus(response, 200, requestId);
+      const result = decodeEntryQueryResultEnvelope(response.body).payload;
+      invariant(result.entry.id === expectedId, `${requestId} returned the wrong entry.`);
+    }
+    expectError(
+      await environment.operations.entryQuery(
+        credentialA,
+        cube,
+        createProtocolEnvelope('entry-query-unknown', { entry_id: 'ffffffff' }),
+      ),
+      404,
+      ErrorCode.NOT_FOUND,
+      'Unknown entry query',
+    );
+    expectError(
+      await environment.operations.entryQuery(
+        credentialA,
+        cube,
+        createProtocolEnvelope('entry-query-ambiguous', { entry_id: '22222222' }),
+      ),
+      409,
+      ErrorCode.LOG_ENTRY_PREFIX_AMBIGUOUS,
+      'Ambiguous entry query',
+    );
+    assertStateDelta(before, await environment.admin.observeAuthorityState(), {}, 'Entry query');
+    const acknowledgementStatus = decodeAckStatusResultEnvelope((await environment.operations.ackStatus(
+      credentialA,
+      cube,
+      createProtocolEnvelope('entry-query-ack-status', { entry_id: ids[0] }),
+    )).body).payload;
+    const claimStatus = decodeAckStatusResultEnvelope((await environment.operations.ackStatus(
+      credentialA,
+      cube,
+      createProtocolEnvelope('entry-query-claim-status', { entry_id: ids[1] }),
+    )).body).payload;
+    invariant(
+      acknowledgementStatus.recipients.some((recipient) =>
+        recipient.drone_id === acknowledgedRecipient.id && recipient.acknowledged_at !== null
+      ),
+      'Entry query removed the seeded acknowledgement.',
+    );
+    invariant(
+      claimStatus.claims.some((claim) => claim.drone_id === claimingRecipient.id),
+      'Entry query removed the seeded claim.',
+    );
+    const unreadResponse = await environment.operations.read(
+      credentialA,
+      cube,
+      createProtocolEnvelope('entry-query-unread', { cursor: null, limit: 10 }),
+    );
+    expectStatus(unreadResponse, 200, 'Entry-query unread read');
+    const unread = decodeReadLogResultEnvelope(unreadResponse.body).payload;
+    invariant(
+      unread.entries.length === entries.length && entries.every((entry) => unread.entries.some((item) => item.id === entry.id)),
+      'Entry query consumed or advanced unread activity.',
+    );
+    return {
+      full_uuid: true,
+      unique_prefix: true,
+      ambiguous_code: ErrorCode.LOG_ENTRY_PREFIX_AMBIGUOUS,
+      unknown_code: ErrorCode.NOT_FOUND,
+      unread_entry_available: true,
+      acknowledgement_preserved: true,
+      claim_preserved: true,
+      mutation: 'none',
+    };
   });
 
   const entries: Array<{ id: string; created_at: string; message: string }> = [];
@@ -1889,6 +2083,7 @@ export async function runAdapterConformance(
         cubeA,
         createProtocolEnvelope(`append-a${index + 1}`, {
           post_id: `00000000-0000-4000-8000-${String(305 + index).padStart(12, '0')}`,
+          to: 'broadcast',
           message,
         }),
       );
@@ -1926,6 +2121,7 @@ export async function runAdapterConformance(
         cubeA,
         createProtocolEnvelope('append-a4', {
           post_id: '00000000-0000-4000-8000-000000000308',
+          to: 'broadcast',
           message: 'delta',
         }),
       );
@@ -1953,6 +2149,7 @@ export async function runAdapterConformance(
         cubeA,
         createProtocolEnvelope('append-a5', {
           post_id: '00000000-0000-4000-8000-000000000309',
+          to: 'broadcast',
           message: 'epsilon',
         }),
       );
@@ -1994,6 +2191,135 @@ export async function runAdapterConformance(
     return { first_status: 204, repeated_status: 204, bodyless: true };
   });
 
+  await record('acks.status-query', async () => {
+    const cube = await environment.admin.createCube('ack-status-cube');
+    await environment.admin.grantCube(principalA, cube);
+    const role = await environment.admin.createRole(cube, {
+      roleClass: 'worker',
+      isHumanSeat: false,
+      name: 'Ack Status Worker',
+    });
+    const acknowledgedRecipient = await environment.admin.createDrone(principalA, cube, role);
+    const claimingRecipient = await environment.admin.createDrone(principalA, cube, role);
+    const acknowledgedCredential = await environment.admin.issueManagedDroneSession(acknowledgedRecipient);
+    const claimingCredential = await environment.admin.issueManagedDroneSession(claimingRecipient);
+    const append = await environment.operations.append(
+      credentialA,
+      cube,
+      createProtocolEnvelope('ack-status-append', {
+        post_id: '00000000-0000-4000-8000-000000000310',
+        to: [acknowledgedRecipient.id, claimingRecipient.id],
+        message: 'START NOW acknowledgement status fixture',
+      }),
+    );
+    expectStatus(append, 201, 'Acknowledgement-status fixture append');
+    const entry = decodeAppendLogResultEnvelope(append.body).payload.entry;
+
+    const beforeMissing = await environment.admin.observeAuthorityState();
+    const missingResponse = await environment.operations.ackStatus(
+      credentialA,
+      cube,
+      createProtocolEnvelope('ack-status-missing', { entry_id: entry.id }),
+    );
+    expectStatus(missingResponse, 200, 'Missing acknowledgement status');
+    const missing = decodeAckStatusResultEnvelope(missingResponse.body).payload;
+    invariant(
+      missing.visibility === 'direct' &&
+        missing.recipients.length === 2 &&
+        missing.recipients.every((recipient) => recipient.acknowledged_at === null) &&
+        missing.claims.length === 0,
+      'Missing acknowledgement was not represented as nullable per-recipient state.',
+    );
+    assertStateDelta(
+      beforeMissing,
+      await environment.admin.observeAuthorityState(),
+      {},
+      'Missing acknowledgement status query',
+    );
+
+    expectStatus(
+      await environment.operations.ack(
+        acknowledgedCredential,
+        cube,
+        createProtocolEnvelope('ack-status-ack', { entry_id: entry.id, kind: 'ack' }),
+      ),
+      204,
+      'Acknowledgement-status acknowledgement',
+    );
+    expectStatus(
+      await environment.operations.ack(
+        claimingCredential,
+        cube,
+        createProtocolEnvelope('ack-status-claim', { entry_id: entry.id, kind: 'claim' }),
+      ),
+      204,
+      'Acknowledgement-status claim',
+    );
+    const beforeDistinct = await environment.admin.observeAuthorityState();
+    const distinctResponse = await environment.operations.ackStatus(
+      credentialA,
+      cube,
+      createProtocolEnvelope('ack-status-distinct', { entry_id: entry.id }),
+    );
+    expectStatus(distinctResponse, 200, 'Distinct acknowledgement and claim status');
+    const distinct = decodeAckStatusResultEnvelope(distinctResponse.body).payload;
+    const acknowledged = distinct.recipients.filter((recipient) => recipient.acknowledged_at !== null);
+    invariant(
+      acknowledged.length === 1 &&
+        acknowledged[0].drone_id === acknowledgedRecipient.id &&
+        distinct.claims.length === 1 &&
+        distinct.claims[0].drone_id === claimingRecipient.id &&
+        distinct.recipients.find((recipient) => recipient.drone_id === claimingRecipient.id)?.acknowledged_at === null,
+      'Acknowledgement status conflated acknowledgement and claim records.',
+    );
+    assertStateDelta(
+      beforeDistinct,
+      await environment.admin.observeAuthorityState(),
+      {},
+      'Distinct acknowledgement and claim status query',
+    );
+
+    const unreadResponse = await environment.operations.read(
+      credentialA,
+      cube,
+      createProtocolEnvelope('ack-status-unread', { cursor: null, limit: 10 }),
+    );
+    expectStatus(unreadResponse, 200, 'Post-query unread read');
+    const unread = decodeReadLogResultEnvelope(unreadResponse.body).payload;
+    invariant(
+      unread.entries.length === 1 && unread.entries[0].id === entry.id,
+      'Acknowledgement-status query advanced unread delivery state.',
+    );
+
+    const beforeUnknown = await environment.admin.observeAuthorityState();
+    expectError(
+      await environment.operations.ackStatus(
+        credentialA,
+        cube,
+        createProtocolEnvelope('ack-status-unknown', {
+          entry_id: '00000000-0000-4000-8000-000000000311',
+        }),
+      ),
+      404,
+      ErrorCode.NOT_FOUND,
+      'Unknown acknowledgement-status entry',
+    );
+    assertStateDelta(
+      beforeUnknown,
+      await environment.admin.observeAuthorityState(),
+      {},
+      'Unknown acknowledgement status query',
+    );
+    return {
+      missing_acknowledgement: null,
+      acknowledgements: 1,
+      claims: 1,
+      distinct: true,
+      unread_entry_available: true,
+      unknown_entry_code: ErrorCode.NOT_FOUND,
+    };
+  });
+
   await record('claims.durable-noncursor', async () => {
     invariant(entries[1] && liveCursor, 'Log fixtures did not produce claim state.');
     const claim = await environment.operations.ack(
@@ -2475,8 +2801,7 @@ export async function runAdapterConformance(
         createProtocolEnvelope('evict-direct-target', {
           message: 'must-not-fan-out',
           post_id: '00000000-0000-4000-8000-000000000310',
-          visibility: 'direct',
-          recipientDroneIds: [evictedDrone.id],
+          to: [evictedDrone.id],
         }),
       ),
       404,
@@ -2556,12 +2881,6 @@ export async function runAdapterConformance(
       isHumanSeat: true,
       name: 'Human Seat',
     });
-    const referencedRole = await environment.admin.createRole(roleContractCube, {
-      roleClass: 'worker',
-      isHumanSeat: false,
-      name: 'Routed Reviewer',
-    });
-    await environment.admin.referenceRoleFromTaxonomy(roleContractCube, referencedRole);
     const activeRole = await environment.admin.createRole(roleContractCube, {
       roleClass: 'worker',
       isHumanSeat: false,
@@ -2573,7 +2892,6 @@ export async function runAdapterConformance(
       [defaultRole, ErrorCode.DEFAULT_ROLE_REQUIRED, 'default role'],
       [mandatoryRole, ErrorCode.ROLE_REQUIRED, 'mandatory role'],
       [humanRole, ErrorCode.ROLE_REQUIRED, 'human-seat role'],
-      [referencedRole, ErrorCode.ROLE_REFERENCED, 'taxonomy-referenced role'],
       [activeRole, ErrorCode.ROLE_IN_USE, 'active-drone role'],
     ] as const;
     for (const [index, [role, code, label]] of refusals.entries()) {
@@ -2666,6 +2984,7 @@ export async function runAdapterConformance(
       roleContractCube,
       createProtocolEnvelope('role-delete-attribution', {
         post_id: '00000000-0000-4000-8000-000000000311',
+        to: 'broadcast',
         message: 'attribution survives',
       }),
     );
@@ -2707,7 +3026,6 @@ export async function runAdapterConformance(
         ErrorCode.ROLE_IN_USE,
         ErrorCode.DEFAULT_ROLE_REQUIRED,
         ErrorCode.ROLE_REQUIRED,
-        ErrorCode.ROLE_REFERENCED,
       ],
       in_use_message_actionable: true,
       evicted_drone_retargeted: true,
@@ -3333,6 +3651,7 @@ export async function runAdapterConformance(
       cube,
       createProtocolEnvelope('delete-log', {
         post_id: '00000000-0000-4000-8000-000000000312',
+        to: 'broadcast',
         message: 'deleted with cube',
       }),
     );