borgmcp-shared 0.14.0 → 1.0.0

package/src/conformance/index.ts

@@ -100,8 +100,6 @@ const APPEND_LOG_ENTRY: EnrichedStreamEntry = {
 const APPEND_LOG_ROUTING = {
   class: 'review',
   recipients: ['one-of-one-reviewer'],
-  fellOpen: false,
-  message: 'Routing applied.',
 } as const;
 
 export interface AppendLogResultConformanceVector {
@@ -119,31 +117,71 @@ export interface AppendLogRequestConformanceVector {
 export interface AppendLogIdempotencyConformanceVector {
   name: string;
   actor: 'same' | 'different';
-  mutation: 'none' | 'message' | 'visibility' | 'recipient_set' | 'ignored_request_shape' | 'resolved_class_routing';
+  mutation: 'none' | 'message' | 'audience' | 'recipient_set' | 'classification';
   expected: 'deduplicated' | 'POST_ID_CONFLICT' | 'created';
 }
 
-/** Author-scoped post identity and exact resolved-routing retry outcomes. */
+/** Author-scoped post identity and exact resolved-delivery retry outcomes. */
 export const APPEND_LOG_IDEMPOTENCY_CONFORMANCE: readonly AppendLogIdempotencyConformanceVector[] = [
   { name: 'deduplicates an exact same-author retry', actor: 'same', mutation: 'none', expected: 'deduplicated' },
   { name: 'rejects a same-author message collision', actor: 'same', mutation: 'message', expected: 'POST_ID_CONFLICT' },
-  { name: 'rejects a same-author visibility collision', actor: 'same', mutation: 'visibility', expected: 'POST_ID_CONFLICT' },
+  { name: 'rejects a same-author audience collision', actor: 'same', mutation: 'audience', expected: 'POST_ID_CONFLICT' },
   { name: 'rejects a same-author recipient-set collision', actor: 'same', mutation: 'recipient_set', expected: 'POST_ID_CONFLICT' },
-  { name: 'deduplicates ignored class selectors with identical resolved delivery', actor: 'same', mutation: 'ignored_request_shape', expected: 'deduplicated' },
-  { name: 'rejects a same-author resolved class-routing collision', actor: 'same', mutation: 'resolved_class_routing', expected: 'POST_ID_CONFLICT' },
+  { name: 'deduplicates changed classification with identical explicit delivery', actor: 'same', mutation: 'classification', expected: 'deduplicated' },
   { name: 'creates an independent cross-author post', actor: 'different', mutation: 'none', expected: 'created' },
 ];
 
 const APPEND_LOG_REQUEST = {
   post_id: '00000000-0000-4000-8000-000000000205',
   message: 'REVIEW-READY: example',
+  to: 'broadcast',
 } satisfies AppendLogRequest;
 
 export const APPEND_LOG_REQUEST_CONFORMANCE: readonly AppendLogRequestConformanceVector[] = [
   { name: 'accepts a canonical post UUID', request: APPEND_LOG_REQUEST, accepts: true },
-  { name: 'rejects an omitted post UUID', request: { message: APPEND_LOG_REQUEST.message }, accepts: false },
+  { name: 'rejects an omitted post UUID', request: { message: APPEND_LOG_REQUEST.message, to: 'broadcast' }, accepts: false },
   { name: 'rejects an invalid post UUID', request: { ...APPEND_LOG_REQUEST, post_id: 'not-a-uuid' }, accepts: false },
   { name: 'rejects unknown request fields', request: { ...APPEND_LOG_REQUEST, extra: true }, accepts: false },
+  {
+    name: 'rejects omitted addressing',
+    request: { post_id: APPEND_LOG_REQUEST.post_id, message: APPEND_LOG_REQUEST.message },
+    accepts: false,
+  },
+  {
+    name: 'accepts explicit broadcast addressing',
+    request: APPEND_LOG_REQUEST,
+    accepts: true,
+  },
+  {
+    name: 'accepts a non-empty recipient selector union branch',
+    request: { ...APPEND_LOG_REQUEST, to: ['Builder', 'id:3336cde1'] },
+    accepts: true,
+  },
+  {
+    name: 'rejects null addressing',
+    request: { ...APPEND_LOG_REQUEST, to: null },
+    accepts: false,
+  },
+  {
+    name: 'rejects an empty recipient selector array',
+    request: { ...APPEND_LOG_REQUEST, to: [] },
+    accepts: false,
+  },
+  {
+    name: 'rejects an arbitrary scalar audience',
+    request: { ...APPEND_LOG_REQUEST, to: 'all' },
+    accepts: false,
+  },
+  {
+    name: 'rejects retired visibility without falling open',
+    request: { ...APPEND_LOG_REQUEST, visibility: 'broadcast' },
+    accepts: false,
+  },
+  {
+    name: 'rejects retired recipient ids without falling open',
+    request: { ...APPEND_LOG_REQUEST, recipientDroneIds: ['00000000-0000-4000-8000-000000000204'] },
+    accepts: false,
+  },
 ];
 
 /** Runtime response vectors keep the append-log decoder aligned with its public type. */
@@ -214,13 +252,8 @@ export const APPEND_LOG_RESULT_CONFORMANCE: readonly AppendLogResultConformanceV
     accepts: false,
   },
   {
-    name: 'rejects an invalid routing fell-open flag',
-    response: { entry: APPEND_LOG_ENTRY, deduplicated: false, routing: { ...APPEND_LOG_ROUTING, fellOpen: 'false' } },
-    accepts: false,
-  },
-  {
-    name: 'rejects an invalid routing message',
-    response: { entry: APPEND_LOG_ENTRY, deduplicated: false, routing: { ...APPEND_LOG_ROUTING, message: 7 } },
+    name: 'rejects legacy fall-open routing metadata',
+    response: { entry: APPEND_LOG_ENTRY, deduplicated: false, routing: { ...APPEND_LOG_ROUTING, fellOpen: false } },
     accepts: false,
   },
   {
@@ -883,7 +916,6 @@ export interface RoleDeleteConformanceVector {
     | 'default'
     | 'mandatory'
     | 'human-seat'
-    | 'taxonomy-reference'
     | 'unknown';
   expected:
     | {
@@ -895,7 +927,7 @@ export interface RoleDeleteConformanceVector {
     }
     | {
       status: 409;
-      error: 'ROLE_IN_USE' | 'DEFAULT_ROLE_REQUIRED' | 'ROLE_REQUIRED' | 'ROLE_REFERENCED';
+      error: 'ROLE_IN_USE' | 'DEFAULT_ROLE_REQUIRED' | 'ROLE_REQUIRED';
       mutation: 'none';
       message?: typeof ROLE_IN_USE_DELETE_MESSAGE;
     }
@@ -945,11 +977,6 @@ export const ROLE_DELETE_CONFORMANCE: readonly RoleDeleteConformanceVector[] = [
     fixture: 'human-seat',
     expected: { status: 409, error: 'ROLE_REQUIRED', mutation: 'none' },
   },
-  {
-    name: 'refuses a taxonomy default-recipient role',
-    fixture: 'taxonomy-reference',
-    expected: { status: 409, error: 'ROLE_REFERENCED', mutation: 'none' },
-  },
   {
     name: 'hides an unknown or inaccessible role',
     fixture: 'unknown',
@@ -1046,6 +1073,45 @@ export const ACK_STATUS_CONFORMANCE: readonly AckStatusConformanceVector[] = [
   },
 ];
 
+export interface EntryQueryConformanceVector {
+  name: string;
+  fixture: 'full-uuid' | 'unique-prefix' | 'unknown' | 'ambiguous-prefix' | 'read-only';
+  expected:
+    | { status: 200; exact_entry: true; mutation: 'none' }
+    | { status: 404; error: 'NOT_FOUND'; mutation: 'none' }
+    | { status: 409; error: 'LOG_ENTRY_PREFIX_AMBIGUOUS'; mutation: 'none' }
+    | { status: 200; unread_entry_available: true; mutation: 'none' };
+}
+
+/** Portable exact-entry lookup outcomes for canonical UUID and short-prefix selectors. */
+export const ENTRY_QUERY_CONFORMANCE: readonly EntryQueryConformanceVector[] = [
+  {
+    name: 'resolves one canonical full UUID',
+    fixture: 'full-uuid',
+    expected: { status: 200, exact_entry: true, mutation: 'none' },
+  },
+  {
+    name: 'resolves one unique eight-hex prefix',
+    fixture: 'unique-prefix',
+    expected: { status: 200, exact_entry: true, mutation: 'none' },
+  },
+  {
+    name: 'hides an unknown or inaccessible selector',
+    fixture: 'unknown',
+    expected: { status: 404, error: 'NOT_FOUND', mutation: 'none' },
+  },
+  {
+    name: 'refuses an ambiguous eight-hex prefix',
+    fixture: 'ambiguous-prefix',
+    expected: { status: 409, error: 'LOG_ENTRY_PREFIX_AMBIGUOUS', mutation: 'none' },
+  },
+  {
+    name: 'does not advance unread or mutate acknowledgement, claim, log, or authority state',
+    fixture: 'read-only',
+    expected: { status: 200, unread_entry_available: true, mutation: 'none' },
+  },
+];
+
 /** One canonical corpus consumed unchanged by shared, server, and client tests. */
 export const RUNTIME_METADATA_REPOSITORY_CONFORMANCE:
 readonly RuntimeMetadataRepositoryConformanceVector[] = [

package/src/protocol/contract.ts

@@ -13,7 +13,7 @@ import type {
 } from './types.js';
 
 export const SHARED_PACKAGE_NAME = 'borgmcp-shared' as const;
-export const SHARED_PACKAGE_VERSION = '0.14.0' as const;
+export const SHARED_PACKAGE_VERSION = '1.0.0' as const;
 /** Maximum UTF-8 payload for each newly recorded decision text field. */
 export const DECISION_TEXT_MAX_BYTES = 512 as const;
 /** Maximum UTF-8 size of role detailed-description text and any returned section slice. */
@@ -590,7 +590,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 v11. The peer presents a different version. Update `borgmcp-server` and `borgmcp` to matching releases — server first, then client.',
+      'This client requires protocol v12. The peer presents a different version. Update `borgmcp-server` and `borgmcp` to matching releases — server first, then client.',
       ErrorCode.UNSUPPORTED_PROTOCOL_VERSION,
       ['protocol_version'],
     );
@@ -1007,33 +1007,17 @@ export function decodeAppendLogRequest(value: unknown): import('./types.js').App
   const input = record(value);
   exactKeys(
     input,
-    ['post_id', 'message', 'visibility', 'recipientDroneIds', 'class', 'to', 'documents'],
-    ['post_id', 'message'],
+    ['post_id', 'message', 'to', 'class', 'documents'],
+    ['post_id', 'message', 'to'],
   );
   const output: import('./types.js').AppendLogRequest = {
     post_id: decodeUuid(input.post_id, ['post_id']),
     message: boundedString(input.message, 1, PROTOCOL_LIMIT_CEILINGS.max_log_message_bytes, ['message']),
+    to: input.to === 'broadcast' ? 'broadcast' : decodeRecipientSelectors(input.to),
   };
-  if (input.visibility !== undefined) {
-    if (input.visibility !== 'broadcast' && input.visibility !== 'direct') {
-      fail('Invalid log visibility.', ['visibility']);
-    }
-    output.visibility = input.visibility;
-  }
-  if (input.recipientDroneIds !== undefined) {
-    if (!Array.isArray(input.recipientDroneIds) || input.recipientDroneIds.length === 0 || input.recipientDroneIds.length > 100) {
-      fail('Expected recipientDroneIds to contain 1-100 UUIDs.', ['recipientDroneIds']);
-    }
-    output.recipientDroneIds = input.recipientDroneIds.map((id, index) =>
-      decodeUuid(id, ['recipientDroneIds', index])
-    );
-  }
   if (input.class !== undefined) {
     output.class = boundedString(input.class, 1, 64, ['class']);
   }
-  if (input.to !== undefined) {
-    output.to = decodeStringArray(input.to, 'to', 100, 120);
-  }
   if (input.documents !== undefined) {
     output.documents = decodeStringArray(input.documents, 'documents', 100, 128)
       .map((id, index) => decodeOpaqueIdentifier(id, ['documents', index]));
@@ -1041,6 +1025,16 @@ export function decodeAppendLogRequest(value: unknown): import('./types.js').App
   return output;
 }
 
+function decodeRecipientSelectors(value: unknown): string[] {
+  const selectors = decodeStringArray(value, 'to', 100, 120);
+  for (const [index, selector] of selectors.entries()) {
+    if (selector !== selector.trim() || /[\u0000-\u001f\u007f-\u009f]/.test(selector)) {
+      fail('Recipient selectors must be trimmed and control-free.', ['to', index]);
+    }
+  }
+  return selectors;
+}
+
 function decodeStringArray(value: unknown, field: string, maxItems: number, maxLength: number): string[] {
   if (!Array.isArray(value) || value.length === 0 || value.length > maxItems) {
     fail(`Expected ${field} to contain 1-${maxItems} values.`, [field]);

package/src/protocol/coordination.ts

@@ -47,6 +47,14 @@ export interface ReadLogResult {
   claims: ClaimRecord[];
 }
 
+export interface EntryQueryRequest {
+  entry_id: string;
+}
+
+export interface EntryQueryResult {
+  entry: EnrichedStreamEntry;
+}
+
 export interface AckStatusRequest {
   entry_id: string;
 }
@@ -335,6 +343,32 @@ export function decodeReadLogRequestEnvelope(
   return decodeProtocolEnvelope(value, decodeReadLogRequest);
 }
 
+export function decodeEntryQueryRequest(value: unknown): EntryQueryRequest {
+  const input = object(value);
+  exact(input, ['entry_id'], ['entry_id']);
+  const entryId = boundedString(input.entry_id, 'entry_id', 36);
+  if (/^[0-9a-f]{8}$/i.test(entryId)) return { entry_id: entryId.toLowerCase() };
+  return { entry_id: decodeUuid(entryId, ['entry_id']) };
+}
+
+export function decodeEntryQueryRequestEnvelope(
+  value: unknown,
+): ProtocolEnvelope<EntryQueryRequest> {
+  return decodeProtocolEnvelope(value, decodeEntryQueryRequest);
+}
+
+export function decodeEntryQueryResult(value: unknown): EntryQueryResult {
+  const input = object(value);
+  exact(input, ['entry'], ['entry']);
+  return { entry: decodeEnrichedStreamEntry(input.entry) };
+}
+
+export function decodeEntryQueryResultEnvelope(
+  value: unknown,
+): ProtocolEnvelope<EntryQueryResult> {
+  return decodeProtocolEnvelope(value, decodeEntryQueryResult);
+}
+
 export function decodeAckStatusRequest(value: unknown): AckStatusRequest {
   const input = object(value);
   exact(input, ['entry_id'], ['entry_id']);
@@ -445,22 +479,17 @@ function decodeRoutingEcho(value: unknown): RoutingEcho {
   const input = object(value);
   exact(
     input,
-    ['class', 'recipients', 'fellOpen', 'message'],
-    ['class', 'recipients', 'fellOpen', 'message'],
+    ['class', 'recipients'],
+    ['class', 'recipients'],
   );
   if (!Array.isArray(input.recipients) || input.recipients.length > 100) {
     throw new ProtocolContractError('Invalid routing recipient list.');
   }
-  if (typeof input.fellOpen !== 'boolean') {
-    throw new ProtocolContractError('Invalid routing fell-open flag.');
-  }
   return {
     class: nullableString(input.class, 'routing.class', 64),
     recipients: input.recipients.map((recipient) =>
       boundedString(recipient, 'routing.recipients', 120)
     ),
-    fellOpen: input.fellOpen,
-    message: nullableString(input.message, 'routing.message', 512),
   };
 }
 

package/src/protocol/errors.ts

@@ -15,10 +15,10 @@ export enum ErrorCode {
   REPOSITORY_ALREADY_ASSOCIATED = 'REPOSITORY_ALREADY_ASSOCIATED',
   CUBE_ALREADY_ASSOCIATED = 'CUBE_ALREADY_ASSOCIATED',
   POST_ID_CONFLICT = 'POST_ID_CONFLICT',
+  LOG_ENTRY_PREFIX_AMBIGUOUS = 'LOG_ENTRY_PREFIX_AMBIGUOUS',
   ROLE_IN_USE = 'ROLE_IN_USE',
   DEFAULT_ROLE_REQUIRED = 'DEFAULT_ROLE_REQUIRED',
   ROLE_REQUIRED = 'ROLE_REQUIRED',
-  ROLE_REFERENCED = 'ROLE_REFERENCED',
   ROLE_NOT_FOUND = 'ROLE_NOT_FOUND',
   ROLE_SECTION_NOT_FOUND = 'ROLE_SECTION_NOT_FOUND',
   ROLE_HAS_FROZEN_DRONES = 'ROLE_HAS_FROZEN_DRONES',

package/src/protocol/types.ts

@@ -168,17 +168,13 @@ export interface ReadLogResponse {
 export interface RoutingEcho {
   class: string | null;
   recipients: string[];
-  fellOpen: boolean;
-  message: string | null;
 }
 
 export interface AppendLogRequest {
   post_id: string;
   message: string;
-  visibility?: LogVisibility;
-  recipientDroneIds?: string[];
+  to: 'broadcast' | string[];
   class?: string;
-  to?: string[];
   documents?: string[];
 }
 

package/src/protocol/version.ts

@@ -1,4 +1,4 @@
-/** Current Borg coordination protocol generation. Clean-slate v11. */
-export const PROTOCOL_VERSION = '11' as const;
+/** Current Borg coordination protocol generation. Clean-slate v12. */
+export const PROTOCOL_VERSION = '12' as const;
 
 export type ProtocolVersion = typeof PROTOCOL_VERSION;

package/src/templates.ts

@@ -21,8 +21,6 @@ export interface TemplateRole {
 export interface MessageTaxonomyClass {
   class: string;
   prefixes?: string[];
-  routing: 'broadcast' | 'directed';
-  default_to?: string[];
   lifecycle?: 'dispatch' | 'completion';
 }
 
@@ -156,7 +154,7 @@ Same-repository workflow policy:
 - Run \`git remote get-url origin\` to determine whether a hosted origin exists.
 - When that command succeeds, publish the branch with \`git push -u origin <branch>\`; the branch is REVIEW-READY only after that push and exact remote-head verification.
 - When that command fails because no origin exists, omit the push; the work is REVIEW-READY when its exact commit SHA is available through the project review mechanism.
-- After every merge to the protected or main branch, broadcast the merge SHA.`;
+- After every merge to the protected or main branch, post the merge SHA with \`to: "broadcast"\`.`;
 
 export const UNIVERSAL_SAFETY_DISCIPLINES = [WAKE_PATH_MONITOR_DISCIPLINE];
 
@@ -179,9 +177,10 @@ Drone addressing:
 const STRUCTURED_MESSAGE_ROUTING_DISCIPLINE = `
 
 Structured message routing:
-- Pass the intended recipient through borg_log's structured \`to:\` parameter for every directed message.
+- Every borg_log call must set structured \`to:\` to either \`"broadcast"\` or a non-empty recipient selector array.
+- Use \`to: "broadcast"\` only when every cube member is the intended audience; otherwise name every intended recipient explicitly.
 - Naming a recipient inside the message text does not route it.
-- The default is broadcast. Without \`to:\`, a matching directed class, or explicit direct visibility, the unrouted message broadcasts to every seat.`;
+- Message classes and prefixes classify lifecycle signals only; they never choose recipients or provide a default audience.`;
 
 const DIRECTED_DISCUSSION_DISCIPLINE = `
 - Use QUESTION, ANSWER, or HEADS-UP with \`to:\` for directed discussion outside the role's terminal workflow signals.`;
@@ -215,82 +214,57 @@ const SOFTWARE_DEV_TAXONOMY: MessageTaxonomy = [
   {
     class: 'status-claim',
     prefixes: ['STARTING', 'PROGRESS', 'ACK', 'PONG', 'PUSHING'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'completion-status',
     prefixes: ['DONE'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
     lifecycle: 'completion',
   },
   {
     class: 'review-request',
     prefixes: ['REVIEW-READY'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'review-feedback',
     prefixes: ['REVIEW-FEEDBACK', 'RQ-FEEDBACK', 'SECURITY-FEEDBACK', 'PD-FEEDBACK', 'PS-FEEDBACK'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'completion-gate',
     prefixes: ['REVIEW-APPROVED', 'RQ-APPROVED', 'SECURITY-APPROVED', 'PD-APPROVED', 'PS-APPROVED'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
     lifecycle: 'completion',
   },
   {
     class: 'blocked-signal',
     prefixes: ['BLOCKED'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'dispatch-routing',
     prefixes: ['START NOW', 'RESUME NOW', 'REVIEW NOW', 'HOLD'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
     lifecycle: 'dispatch',
   },
   {
     class: 'ping',
     prefixes: ['PING'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'peer-question',
     prefixes: ['QUESTION', 'ASK'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'peer-answer',
     prefixes: ['ANSWER'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'peer-heads-up',
     prefixes: ['HEADS-UP'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'finding',
     prefixes: ['PROPOSAL'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'cube-wide',
     prefixes: ['DECISION', 'HALT', 'MERGED'],
-    routing: 'broadcast',
   },
 ];
 
@@ -327,7 +301,7 @@ Communication:
 - Surface decisions, blockers, asks, and material evidence in the human conversation, not only the cube log.
 - Distinguish read-only findings, proposals, completed actions, and actions awaiting authority.
 - Send START NOW, RESUME NOW, REVIEW NOW, and HOLD with \`to:\` to the named implementer or reviewer. Use \`to:\` for every later directed transition.
-- Send PING with \`to:\` only for a directed liveness check. Use DECISION or HALT only for an intentional cube-wide human-seat message. After an authorized merge, broadcast MERGED with the exact merge SHA.
+- Send PING with \`to:\` only for a directed liveness check. Use DECISION or HALT with \`to: "broadcast"\` only for an intentional cube-wide human-seat message. After an authorized merge, post MERGED with the exact merge SHA and \`to: "broadcast"\`.
 - Keep the primary playbook operational and concise. Delete obsolete, redundant, historical, cautionary, and example-heavy prose; do not relocate it into new runbooks, decisions, contracts, rationale, or case-study archives unless it has a current operational consumer.
 
 Builders implement; reviewers review; you coordinate. Integrate only when authorized.${COORDINATOR_FINDING_DISPATCH_DISCIPLINE}${SERIALIZED_REVIEW_ROUNDS_DISCIPLINE}${GIT_OPERATIONAL_DISCIPLINE_COORDINATOR}${PUSH_DISCIPLINE_COORDINATOR}${DRONE_ADDRESSING_CONVENTION}${STRUCTURED_MESSAGE_ROUTING_DISCIPLINE}${DIRECTED_DISCUSSION_DISCIPLINE}${RECEIPT_AND_LIVENESS_DISCIPLINE}${OPERATOR_CONTROLLED_OWNERSHIP_DISCIPLINE}`;
@@ -508,76 +482,53 @@ const STARTER_TAXONOMY: MessageTaxonomy = [
   {
     class: 'status-claim',
     prefixes: ['STARTING', 'PROGRESS', 'ACK', 'PONG'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'completion-status',
     prefixes: ['DONE'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
     lifecycle: 'completion',
   },
   {
     class: 'review-request',
     prefixes: ['REVIEW-READY'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'review-feedback',
     prefixes: ['FEEDBACK'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'completion-gate',
     prefixes: ['APPROVED'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
     lifecycle: 'completion',
   },
   {
     class: 'blocked-signal',
     prefixes: ['BLOCKED'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'dispatch-routing',
     prefixes: ['START NOW', 'RESUME NOW', 'REVIEW NOW', 'HOLD'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
     lifecycle: 'dispatch',
   },
   {
     class: 'ping',
     prefixes: ['PING'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'peer-question',
     prefixes: ['QUESTION', 'ASK'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'peer-answer',
     prefixes: ['ANSWER'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'peer-heads-up',
     prefixes: ['HEADS-UP'],
-    routing: 'directed',
-    default_to: ['coordinator', 'queen'],
   },
   {
     class: 'cube-wide',
     prefixes: ['DECISION', 'HALT'],
-    routing: 'broadcast',
   },
 ];
 
@@ -606,7 +557,7 @@ const STARTER: Template = {
 - Questions, findings, proposals, open queues, and spare capacity do not authorize new work.
 - Route completed work to the Reviewer only when review is required.
 - Send START NOW, RESUME NOW, REVIEW NOW, and HOLD with \`to:\` to the named Worker or Reviewer.
-- Send PING with \`to:\` only for a directed liveness check. Use DECISION or HALT only for an intentional cube-wide human-seat message.
+- Send PING with \`to:\` only for a directed liveness check. Use DECISION or HALT with \`to: "broadcast"\` only for an intentional cube-wide human-seat message.
 - Ask the human before rescoping, abandoning, waiving, merging, shipping, publishing, or taking an irreversible action unless already delegated.
 - Waiting is valid when work is complete, blocked, under review, or awaiting authority.${COORDINATOR_FINDING_DISPATCH_DISCIPLINE}${ANTI_PASSIVE_STANDING_DISCIPLINE}${DRONE_ADDRESSING_CONVENTION}${STRUCTURED_MESSAGE_ROUTING_DISCIPLINE}${DIRECTED_DISCUSSION_DISCIPLINE}${RECEIPT_AND_LIVENESS_DISCIPLINE}${OPERATOR_CONTROLLED_OWNERSHIP_DISCIPLINE}`,
     },
@@ -642,83 +593,58 @@ const LOCAL_MODEL_TAXONOMY: MessageTaxonomy = [
   {
     class: 'executor-echo',
     prefixes: ['PACKET-ECHO'],
-    routing: 'directed',
-    default_to: ['shaper'],
   },
   {
     class: 'executor-refusal',
     prefixes: ['SPEC-GAP'],
-    routing: 'directed',
-    default_to: ['shaper'],
   },
   {
     class: 'executor-completion',
     prefixes: ['PACKET-DONE'],
-    routing: 'directed',
-    default_to: ['shaper'],
     lifecycle: 'completion',
   },
   {
     class: 'packet-dispatch',
     prefixes: ['EXECUTE PACKET'],
-    routing: 'directed',
-    default_to: ['executor'],
     lifecycle: 'dispatch',
   },
   {
     class: 'packet-verdict',
     prefixes: ['ACCEPT', 'REJECT'],
-    routing: 'directed',
-    default_to: ['executor'],
   },
   {
     class: 'blocked-signal',
     prefixes: ['BLOCKED'],
-    routing: 'directed',
-    default_to: ['director', 'queen'],
   },
   {
     class: 'review-request',
     prefixes: ['REVIEW-READY'],
-    routing: 'directed',
-    default_to: ['director', 'queen'],
   },
   {
     class: 'director-dispatch',
     prefixes: ['DISPATCH', 'HOLD'],
-    routing: 'directed',
-    default_to: ['shaper'],
     lifecycle: 'dispatch',
   },
   {
     class: 'director-approval',
     prefixes: ['APPROVED'],
-    routing: 'directed',
-    default_to: ['shaper'],
     lifecycle: 'completion',
   },
   {
     class: 'peer-question',
     prefixes: ['QUESTION'],
-    routing: 'directed',
-    default_to: ['director', 'queen'],
   },
   {
     class: 'peer-answer',
     prefixes: ['ANSWER'],
-    routing: 'directed',
-    default_to: ['director', 'queen'],
   },
   {
     class: 'peer-heads-up',
     prefixes: ['HEADS-UP'],
-    routing: 'directed',
-    default_to: ['director', 'queen'],
   },
   {
     class: 'cube-wide',
     prefixes: ['DECISION'],
-    routing: 'broadcast',
   },
 ];
 
@@ -754,7 +680,7 @@ Direction and verification:
 - Never approve work you authored. If the Shaper implemented an unconvertible item, you are its independent verifier.
 
 Continuity:
-- Send DISPATCH, HOLD, APPROVED, QUESTION, ANSWER, and HEADS-UP with \`to:\` to the Shaper. Use DECISION only when the message is intentionally cube-wide.
+- Send DISPATCH, HOLD, APPROVED, QUESTION, ANSWER, and HEADS-UP with \`to:\` to the Shaper. Use DECISION with \`to: "broadcast"\` only when the message is intentionally cube-wide.
 - DISPATCH, HOLD, and DECISION are not completion when they leave an authorized follow-on action.
 - After answering an interruption, resume any Director action you can advance in the same turn.
 - Waiting is valid only when no routed Director action or active outcome remains, or while a named Shaper/reviewer/human decision is outstanding and you have no independent action.