borgmcp-shared 0.6.4 → 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,9 +3,11 @@ import type {
   AttachResponse,
   AssociateRepositoryCubeRequest,
   CreateCubeRequest,
+  DeleteCubeRequest,
   EnrollmentExchangeRequest,
   ResolveRepositoryCubeRequest,
 } from '../protocol/contract.js';
+import type { EnrichedStreamEntry } from '../protocol/types.js';
 
 export * from './adapter.js';
 
@@ -67,6 +69,138 @@ export const DRONE_ADDRESS_CONFORMANCE: readonly ConformanceVector<string, strin
   },
 ];
 
+const APPEND_LOG_ENTRY: EnrichedStreamEntry = {
+  id: '00000000-0000-4000-8000-000000000201',
+  cube_id: '00000000-0000-4000-8000-000000000202',
+  drone_id: '00000000-0000-4000-8000-000000000203',
+  message: 'REVIEW-READY: example',
+  visibility: 'direct',
+  created_at: '2026-01-01T00:00:00.000Z',
+  drone_label: 'one-of-one-builder',
+  role_name: 'Builder',
+  recipient_drone_ids: ['00000000-0000-4000-8000-000000000204'],
+};
+
+const APPEND_LOG_ROUTING = {
+  class: 'review',
+  recipients: ['one-of-one-reviewer'],
+  fellOpen: false,
+  message: 'Routing applied.',
+} as const;
+
+export interface AppendLogResultConformanceVector {
+  name: string;
+  response: unknown;
+  accepts: boolean;
+}
+
+/** Runtime response vectors keep the append-log decoder aligned with its public type. */
+export const APPEND_LOG_RESULT_CONFORMANCE: readonly AppendLogResultConformanceVector[] = [
+  {
+    name: 'accepts a response without optional routing metadata',
+    response: { entry: APPEND_LOG_ENTRY },
+    accepts: true,
+  },
+  {
+    name: 'accepts exact routing metadata and unreachable recipients',
+    response: {
+      entry: APPEND_LOG_ENTRY,
+      routing: APPEND_LOG_ROUTING,
+      unreachableRecipients: [{ id: 'missing-reviewer', label: 'Missing Reviewer' }],
+    },
+    accepts: true,
+  },
+  {
+    name: 'accepts a null routing echo and an empty unreachable-recipient list',
+    response: { entry: APPEND_LOG_ENTRY, routing: null, unreachableRecipients: [] },
+    accepts: true,
+  },
+  {
+    name: 'rejects unknown top-level response fields',
+    response: { entry: APPEND_LOG_ENTRY, routing: APPEND_LOG_ROUTING, extra: true },
+    accepts: false,
+  },
+  {
+    name: 'rejects a non-object routing echo',
+    response: { entry: APPEND_LOG_ENTRY, routing: 'review' },
+    accepts: false,
+  },
+  {
+    name: 'rejects missing routing fields',
+    response: { entry: APPEND_LOG_ENTRY, routing: { class: 'review' } },
+    accepts: false,
+  },
+  {
+    name: 'rejects unknown routing fields',
+    response: { entry: APPEND_LOG_ENTRY, routing: { ...APPEND_LOG_ROUTING, extra: true } },
+    accepts: false,
+  },
+  {
+    name: 'rejects an invalid routing class',
+    response: { entry: APPEND_LOG_ENTRY, routing: { ...APPEND_LOG_ROUTING, class: 7 } },
+    accepts: false,
+  },
+  {
+    name: 'rejects an invalid routing recipient collection',
+    response: { entry: APPEND_LOG_ENTRY, routing: { ...APPEND_LOG_ROUTING, recipients: 'reviewer' } },
+    accepts: false,
+  },
+  {
+    name: 'rejects invalid routing recipient members',
+    response: { entry: APPEND_LOG_ENTRY, routing: { ...APPEND_LOG_ROUTING, recipients: [7] } },
+    accepts: false,
+  },
+  {
+    name: 'rejects an invalid routing fell-open flag',
+    response: { entry: APPEND_LOG_ENTRY, routing: { ...APPEND_LOG_ROUTING, fellOpen: 'false' } },
+    accepts: false,
+  },
+  {
+    name: 'rejects an invalid routing message',
+    response: { entry: APPEND_LOG_ENTRY, routing: { ...APPEND_LOG_ROUTING, message: 7 } },
+    accepts: false,
+  },
+  {
+    name: 'rejects a non-array unreachable-recipient list',
+    response: { entry: APPEND_LOG_ENTRY, unreachableRecipients: {} },
+    accepts: false,
+  },
+  {
+    name: 'rejects a non-object unreachable recipient',
+    response: { entry: APPEND_LOG_ENTRY, unreachableRecipients: ['missing-reviewer'] },
+    accepts: false,
+  },
+  {
+    name: 'rejects missing unreachable-recipient fields',
+    response: { entry: APPEND_LOG_ENTRY, unreachableRecipients: [{ id: 'missing-reviewer' }] },
+    accepts: false,
+  },
+  {
+    name: 'rejects unknown unreachable-recipient fields',
+    response: {
+      entry: APPEND_LOG_ENTRY,
+      unreachableRecipients: [{ id: 'missing-reviewer', label: 'Missing Reviewer', extra: true }],
+    },
+    accepts: false,
+  },
+  {
+    name: 'rejects an invalid unreachable-recipient id',
+    response: {
+      entry: APPEND_LOG_ENTRY,
+      unreachableRecipients: [{ id: 7, label: 'Missing Reviewer' }],
+    },
+    accepts: false,
+  },
+  {
+    name: 'rejects an invalid unreachable-recipient label',
+    response: {
+      entry: APPEND_LOG_ENTRY,
+      unreachableRecipients: [{ id: 'missing-reviewer', label: null }],
+    },
+    accepts: false,
+  },
+];
+
 export const ROLE_SECTION_ROUND_TRIP_CONFORMANCE: readonly string[] = [
   '',
   'Preamble only.',
@@ -191,6 +325,23 @@ const CREATE_CUBE_INITIAL: CreateCubeRequest = {
   template: 'default',
 };
 
+export interface CubeTemplateAcceptanceConformanceVector {
+  name: string;
+  template: unknown;
+  accepts: boolean;
+}
+
+/** Protocol v6's complete closed acceptance set for cube-creation templates. */
+export const CUBE_TEMPLATE_ACCEPTANCE_CONFORMANCE:
+readonly CubeTemplateAcceptanceConformanceVector[] = [
+  { name: 'accepts the legacy default template', template: 'default', accepts: true },
+  { name: 'accepts the software-development template', template: 'software-dev', accepts: true },
+  { name: 'accepts the starter template', template: 'starter', accepts: true },
+  { name: 'accepts the local-model template', template: 'local-model', accepts: true },
+  { name: 'rejects an unknown template name', template: 'custom', accepts: false },
+  { name: 'rejects a non-string template', template: null, accepts: false },
+];
+
 /** Stateful vectors: name, repository identity, and template bind the retry key. */
 export const CREATE_CUBE_RETRY_CONFORMANCE: readonly CreateCubeRetryConformanceVector[] = [
   {
@@ -293,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.6.4' 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,
@@ -137,7 +146,7 @@ export type EnrollmentExchangeResponse =
   | ClientEnrollmentExchangeResponse
   | OwnerEnrollmentExchangeResponse;
 
-export const CUBE_TEMPLATES = ['default', 'software-dev', 'starter'] as const;
+export const CUBE_TEMPLATES = ['default', 'software-dev', 'starter', 'local-model'] as const;
 export type CubeTemplate = (typeof CUBE_TEMPLATES)[number];
 
 export type CreateCubeRepository =
@@ -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(
-      'Unsupported protocol version.',
+      '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']);