borgmcp-shared 0.2.2 → 0.4.0

package/README.md

@@ -41,7 +41,7 @@ import { ADAPTER_CONFORMANCE_FIXTURES } from 'borgmcp-shared/conformance';
 The supported subpaths are:
 
 - `borgmcp-shared/protocol`: wire entities, requests, responses, errors, and
-  protocol compatibility metadata.
+  the exact protocol version tag.
 - `borgmcp-shared/domain`: pure role-section, address, and high-water-mark
   helpers plus shared domain types.
 - `borgmcp-shared/conformance`: test-runner-independent behavior vectors and
@@ -56,26 +56,40 @@ functions and contracts include API documentation in their TypeScript sources.
 
 ## Handshake
 
-The first-slice HTTP contract has three shared paths:
+The first-slice HTTP contract has four shared paths:
 
 - `GET /healthz` is the only unauthenticated liveness probe. Success is `204`
   with no body or identifying metadata.
-- `POST /api/enrollment/exchange` accepts a single-use invitation in a bounded
-  JSON body over verified TLS and returns the client credential once. Secrets
-  never belong in a URL, query string, command-line argument, diagnostic, or
-  serializable domain entity.
-- `GET /api/protocol` requires authentication and returns the protocol version,
-  package version, capabilities, and bounded limits in the shared envelope.
-
-`negotiateProtocol` requires bearer authentication, revocation, cube isolation,
-verified TLS, and no-cloud-fallback capabilities. Missing security capabilities
-fail closed before an operation begins.
+- `POST /api/enrollment/exchange` accepts a single-use invitation, canonical
+  retry key, and client-generated 256-bit bearer in a bounded JSON body over
+  verified TLS. It returns only stable non-secret client identity and server
+  capabilities; owner enrollment grants `create_cube` but creates no cube. An exact
+  credential-proven retry is non-mutating, and a mismatched replay fails
+  uniformly. Secrets never belong in a response, URL, query string, command-line
+  argument, diagnostic, or serializable domain entity.
+- `GET /api/protocol` is credential-free and mutation-free. It returns ONLY the
+  exact protocol tag — no package version, limits, server identity, or other
+  fingerprint surface — so a client verifies pinned TLS and the exact tag before
+  it creates or sends any credential.
+- `POST /api/cubes` requires an active parent client with `create_cube`. Its
+  strict, idempotent request selects a server-owned template; one atomic success
+  creates a cube, two initial roles, and the creator's cube-scoped `manage`
+  grant. Exact retries return the same non-secret identities without mutation.
+
+`decodeProtocolTagPreflight` fails closed on any tag other than the exact
+expected version, on any extra field, or on a non-object body — before any
+credential is created or sent. The exact protocol tag is the sole acceptance
+authority: there is no capability negotiation, and client and server ship and
+update together as one clean-slate product. The attach request envelope still
+decodes its version before any payload as defense in depth.
 
 Every JSON coordination request and successful JSON response is carried inside
 `ProtocolEnvelope<T>`. Failures use `ProtocolErrorEnvelope`. The only bodyless
 exceptions are the `204` liveness and acknowledgement responses. Payload codecs
 are exported separately so adapters can validate the envelope first and then
 validate the operation-specific payload without accepting ambiguous fields.
+See [docs/enrollment.md](docs/enrollment.md) for purpose-bound owner enrollment,
+ordinary ungranted enrollment, cube creation, pending-keychain, and retry contracts.
 
 ## Conformance
 
@@ -84,7 +98,8 @@ Server and client implementations should run the vectors exported from
 readonly data rather than Vitest-specific helpers, so they work with any test
 runner and in any JavaScript runtime. Cases cover HTTP and canonical errors,
 credential misuse, isolation and revocation, SSE framing/replay/cursor ordering,
-acks, claims, decisions, and unsupported-capability failures.
+executable enrollment authority/retry/mismatch/redaction and cube-create
+idempotency, acks, claims, and decisions.
 
 Implement `AdapterConformanceDriver` with raw responses from the target adapter,
 then call `runAdapterConformance`. The runner creates and decodes envelopes,
@@ -99,32 +114,34 @@ response shapes.
 
 ## Compatibility
 
-`PROTOCOL_VERSION`, `SUPPORTED_PROTOCOL_VERSIONS`, and `COMPATIBILITY_MATRIX`
-describe the compatibility contract. During the pre-1.0 package series, new
-contracts may be added, but an existing wire shape will not change without a
-documented migration path and corresponding conformance coverage. Consumers pin
-`^0.2.0` (`>=0.2.0 <0.3.0`): before 1.0, breaking wire changes increment the
-minor version while compatible additions and corrections increment the patch.
+`PROTOCOL_VERSION` is the sole acceptance authority: every envelope carries the
+protocol tag, and each decoder fails closed on any value other than the exact
+expected tag. There is no capability negotiation, supported-version list,
+compatibility matrix, or version-range fallback. The client and server are one
+clean-slate product — a wire change increments the tag and both adopt it
+together in a coordinated release, with no mixed-version window.
 
-See [docs/compatibility.md](docs/compatibility.md) for the current matrix and
-the policy for introducing protocol changes.
+See [docs/compatibility.md](docs/compatibility.md) for the exact-tag policy and
+the coordinated rollout order for introducing protocol changes.
 
 ## Distribution
 
-After the final source, security, conformance, and packed-artifact gates pass,
-`borgmcp-shared@0.2.2` is published publicly from the npm account that owns the
-existing `borgmcp` client package. Consumers then pin `borgmcp-shared@^0.2.0`
-and commit registry lockfiles. No registry token belongs in this repository,
-package metadata, lockfiles, or a committed `.npmrc`; publishing uses protected
-external credentials and provenance.
-
-Before that publication, consumers may temporarily pin an audited, immutable
-full commit SHA, using
-`git+ssh://git@github.com/Byte-Ventures/borg-mcp-shared.git#<40-hex-SHA>`.
-Tag, range, and local-path pins are prohibited. This exception is replaced with
-the registry dependency `borgmcp-shared@^0.2.0` after publication. Public release
-requires the packed-artifact sensitivity audit, name ownership, account recovery
-and 2FA, provenance verification, and explicit release approval.
+`borgmcp-shared@0.3.0` is the published v1 baseline on the registry (its latest
+release) and is immutable. This source now identifies the still-unpublished
+`0.4.0` candidate for the breaking clean-slate v2 contract — its package
+manifest, lockfile, exported identity, and the SBOM / packed-artifact verifiers
+all read `0.4.0`. This reviewed version bump grants no tag or publish authority
+and must not republish `0.3.0`; creating the annotated `v0.4.0` tag and the
+registry publication remain separate, independently gated steps. After that
+separately authorized registry release, consumers adopting this contract pin
+`borgmcp-shared@^0.4.0` and commit registry lockfiles. No registry token belongs
+in this repository, package metadata, lockfiles, or a committed `.npmrc`;
+publishing uses protected external credentials and provenance.
+
+The first client and server releases must consume the reviewed registry release,
+not a Git, tag, or local-path dependency. Public release requires the
+packed-artifact sensitivity audit, ownership and Trusted Publisher checks,
+provenance verification, and explicit release approval.
 
 ## Security Posture
 

package/dist/conformance/adapter.d.ts

@@ -1,4 +1,4 @@
-import { type LogCursor } from '../protocol/index.js';
+import { type CreateCubeResponse, type LogCursor } from '../protocol/index.js';
 export interface ConformanceHttpResponse {
     status: number;
     body: unknown;
@@ -9,6 +9,28 @@ export interface ConformancePrincipal {
 export interface ConformanceCube {
     readonly id: string;
 }
+export interface ConformanceAuthorityState {
+    enrolled_clients: number;
+    enrollment_claims: number;
+    cubes: number;
+    roles: number;
+    grants: number;
+    server_capabilities: number;
+    cube_create_bindings: number;
+}
+export interface ConformanceCreatedCubeState {
+    cube_exists: boolean;
+    creator_has_grant: boolean;
+    grant_count: number;
+    role_count: number;
+    human_seat_role_matches: boolean;
+    default_worker_role_matches: boolean;
+}
+export interface ConformanceEnrollmentPrincipalState {
+    response_client_matches: boolean;
+    active_credential_bindings: number;
+    bound_credential_matches_enrollment: boolean;
+}
 export interface ConformanceReplayBarrier {
     readonly reached: Promise<void>;
     release(): void;
@@ -21,7 +43,12 @@ export interface ConformanceAdmin {
     createPrincipal(name: string): Promise<ConformancePrincipal>;
     createCube(name: string): Promise<ConformanceCube>;
     grantCube(principal: ConformancePrincipal, cube: ConformanceCube): Promise<void>;
-    issueSingleUseInvitation(principal: ConformancePrincipal): Promise<string>;
+    grantCreateCubeCapability(principal: ConformancePrincipal): Promise<void>;
+    issueDroneSession(principal: ConformancePrincipal): Promise<string>;
+    issueSingleUseInvitation(principal: ConformancePrincipal, purpose: 'owner' | 'client'): Promise<string>;
+    observeAuthorityState(): Promise<ConformanceAuthorityState>;
+    inspectCreatedCube(creator: ConformancePrincipal, response: CreateCubeResponse): Promise<ConformanceCreatedCubeState>;
+    inspectEnrollmentPrincipal(principal: ConformancePrincipal, responseClientId: string): Promise<ConformanceEnrollmentPrincipalState>;
     revokePrincipal(principal: ConformancePrincipal): Promise<void>;
     expireCursor(cube: ConformanceCube, cursor: LogCursor): Promise<void>;
     armReplayTransition(): ConformanceReplayBarrier;
@@ -30,6 +57,7 @@ export interface ConformanceOperations {
     health(): Promise<ConformanceHttpResponse>;
     protocol(credential: string | null): Promise<ConformanceHttpResponse>;
     enroll(request: unknown): Promise<ConformanceHttpResponse>;
+    createCube(credential: string | null, request: unknown): Promise<ConformanceHttpResponse>;
     append(credential: string, cube: ConformanceCube, request: unknown): Promise<ConformanceHttpResponse>;
     appendRaw(credential: string, cube: ConformanceCube, body: string): Promise<ConformanceHttpResponse>;
     read(credential: string, cube: ConformanceCube, request: unknown): Promise<ConformanceHttpResponse>;
@@ -46,8 +74,11 @@ export declare const ADAPTER_CONFORMANCE_FIXTURES: readonly [{
     readonly id: "http.unauthenticated-liveness";
     readonly area: "http";
 }, {
-    readonly id: "protocol.enrollment-auth";
+    readonly id: "protocol.credential-free-preflight";
     readonly area: "protocol";
+}, {
+    readonly id: "enrollment.retry-authority";
+    readonly area: "enrollment";
 }, {
     readonly id: "security.adapter-boundary-injection";
     readonly area: "security";
@@ -75,9 +106,6 @@ export declare const ADAPTER_CONFORMANCE_FIXTURES: readonly [{
 }, {
     readonly id: "decisions.topic-supersession";
     readonly area: "decisions";
-}, {
-    readonly id: "capabilities.unsupported-fails-closed";
-    readonly area: "capabilities";
 }, {
     readonly id: "security.active-stream-revocation";
     readonly area: "security";

package/dist/conformance/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/conformance/adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/conformance/adapter.ts"],"names":[],"mappings":"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"}

package/dist/conformance/adapter.js

@@ -1,7 +1,9 @@
-import { ErrorCode, ProtocolContractError, compareLogCursor, createProtocolEnvelope, decodeAppendLogResultEnvelope, decodeDecisionResultEnvelope, decodeDecisionsResultEnvelope, decodeEnrollmentExchangeResponseEnvelope, decodeProtocolErrorEnvelope, decodeProtocolInfoEnvelope, decodeReadLogResultEnvelope, decodeSseFrames, negotiateProtocol, utf8ByteLength, } from '../protocol/index.js';
+import { ErrorCode, compareLogCursor, createProtocolEnvelope, decodeCreateCubeResponseEnvelope, decodeAppendLogResultEnvelope, decodeDecisionResultEnvelope, decodeDecisionsResultEnvelope, decodeEnrollmentExchangeResponseEnvelope, decodeProtocolErrorEnvelope, decodeProtocolTagPreflight, decodeReadLogResultEnvelope, decodeSseFrames, PROTOCOL_LIMIT_CEILINGS, PROTOCOL_VERSION, utf8ByteLength, } from '../protocol/index.js';
+import { ENROLLMENT_RETRY_CONFORMANCE } from './index.js';
 export const ADAPTER_CONFORMANCE_FIXTURES = [
     { id: 'http.unauthenticated-liveness', area: 'http' },
-    { id: 'protocol.enrollment-auth', area: 'protocol' },
+    { id: 'protocol.credential-free-preflight', area: 'protocol' },
+    { id: 'enrollment.retry-authority', area: 'enrollment' },
     { id: 'security.adapter-boundary-injection', area: 'security' },
     { id: 'security.oversize-request', area: 'security' },
     { id: 'security.cross-cube-isolation', area: 'security' },
@@ -11,7 +13,6 @@ export const ADAPTER_CONFORMANCE_FIXTURES = [
     { id: 'acks.idempotent', area: 'acks' },
     { id: 'claims.durable-noncursor', area: 'claims' },
     { id: 'decisions.topic-supersession', area: 'decisions' },
-    { id: 'capabilities.unsupported-fails-closed', area: 'capabilities' },
     { id: 'security.active-stream-revocation', area: 'security' },
 ];
 const DEFAULT_STREAM_DEADLINE_MS = 5_000;
@@ -116,6 +117,29 @@ function logEvent(event, description) {
 function same(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
+function assertStateDelta(before, after, expected, description) {
+    for (const key of Object.keys(before)) {
+        invariant(after[key] - before[key] === (expected[key] ?? 0), `${description} changed ${key} by ${after[key] - before[key]}; expected ${expected[key] ?? 0}.`);
+    }
+}
+function assertEnrollmentErrorIsSecretFree(response, requests, description) {
+    const diagnostic = JSON.stringify(response.body);
+    const secrets = new Set(requests.flatMap((request) => [
+        request.invitation,
+        request.retry_key,
+        request.client_credential,
+    ]));
+    for (const secret of secrets) {
+        invariant(!diagnostic.includes(secret), `${description} exposed enrollment retry material.`);
+    }
+}
+function expectSecretFreeError(response, status, code, operation, secrets) {
+    expectError(response, status, code, operation);
+    const diagnostic = JSON.stringify(response.body);
+    for (const secret of new Set(secrets)) {
+        invariant(!diagnostic.includes(secret), `${operation} exposed retry material.`);
+    }
+}
 export async function runAdapterConformance(environment, options = {}) {
     const streamDeadlineMs = options.streamDeadlineMs ?? DEFAULT_STREAM_DEADLINE_MS;
     const pendingProbeMs = options.pendingProbeMs ?? DEFAULT_PENDING_PROBE_MS;
@@ -136,66 +160,219 @@ export async function runAdapterConformance(environment, options = {}) {
         }
     };
     await environment.admin.reset();
-    const principalA = await environment.admin.createPrincipal('principal-a');
-    const principalB = await environment.admin.createPrincipal('principal-b');
-    const cubeA = await environment.admin.createCube('cube-a');
-    const cubeB = await environment.admin.createCube('cube-b');
-    await environment.admin.grantCube(principalA, cubeA);
-    await environment.admin.grantCube(principalB, cubeB);
-    const invitationA = await environment.admin.issueSingleUseInvitation(principalA);
-    const invitationB = await environment.admin.issueSingleUseInvitation(principalB);
+    let principalA;
+    let principalB;
+    let cubeA;
+    let cubeB;
     let credentialA = '';
     let credentialB = '';
-    let protocolBody;
-    let protocolInfo = null;
     await record('http.unauthenticated-liveness', async () => {
         const response = await environment.operations.health();
         expectStatus(response, 204, 'Unauthenticated liveness');
         invariant(response.body === '' || response.body === undefined, 'Unauthenticated liveness exposed a response body.');
         return { status: 204, bodyless: true };
     });
-    await record('protocol.enrollment-auth', async () => {
-        expectError(await environment.operations.protocol(null), 401, ErrorCode.AUTH_MISSING, 'Unauthenticated protocol request');
+    await record('protocol.credential-free-preflight', async () => {
+        const before = await environment.admin.observeAuthorityState();
+        const response = await environment.operations.protocol(null);
+        expectStatus(response, 200, 'Credential-free protocol-tag preflight');
+        const preflight = decodeProtocolTagPreflight(response.body);
+        invariant(Object.keys(preflight).length === 1 && preflight.protocol_version === PROTOCOL_VERSION, 'Protocol-tag preflight exposed more than the exact tag.');
+        assertStateDelta(before, await environment.admin.observeAuthorityState(), {}, 'Protocol-tag preflight');
+        return { authenticated: false, mutation_free: true, protocol_version: preflight.protocol_version };
+    });
+    await record('enrollment.retry-authority', async () => {
+        const retryVectorErrors = [];
+        for (const [index, vector] of ENROLLMENT_RETRY_CONFORMANCE.entries()) {
+            for (const purpose of ['client', 'owner']) {
+                await environment.admin.reset();
+                try {
+                    const principal = await environment.admin.createPrincipal(`${purpose}-retry-vector-${index}`);
+                    const invitation = await environment.admin.issueSingleUseInvitation(principal, purpose);
+                    const initialPayload = { ...vector.initial, invitation };
+                    const retryPayload = { ...vector.retry, invitation };
+                    const beforeInitial = await environment.admin.observeAuthorityState();
+                    const initialResponse = await environment.operations.enroll(createProtocolEnvelope(`retry-${index}-initial`, initialPayload));
+                    expectStatus(initialResponse, 201, `${vector.name} initial request`);
+                    const initial = decodeEnrollmentExchangeResponseEnvelope(initialResponse.body).payload;
+                    invariant(initial.purpose === purpose, `${purpose} ${vector.name} returned the wrong purpose.`);
+                    invariant(same(initial.server_capabilities, purpose === 'owner' ? ['create_cube'] : []), `${purpose} ${vector.name} returned incorrect server authority.`);
+                    const afterInitial = await environment.admin.observeAuthorityState();
+                    assertStateDelta(beforeInitial, afterInitial, {
+                        enrolled_clients: 1,
+                        enrollment_claims: 1,
+                        server_capabilities: purpose === 'owner' ? 1 : 0,
+                    }, `${purpose} ${vector.name} initial request`);
+                    const beforeRetry = await environment.admin.observeAuthorityState();
+                    const retryResponse = await environment.operations.enroll(createProtocolEnvelope(`retry-${index}-retry`, retryPayload));
+                    if (vector.expected.outcome === 'stable_non_secret_identity') {
+                        expectStatus(retryResponse, 201, `${purpose} ${vector.name}`);
+                        const retry = decodeEnrollmentExchangeResponseEnvelope(retryResponse.body).payload;
+                        invariant(same(initial, retry), `${purpose} ${vector.name} returned different identities.`);
+                        for (const field of vector.expected.forbidden_response_fields) {
+                            invariant(!(field in retry), `${purpose} ${vector.name} returned forbidden field ${field}.`);
+                        }
+                    }
+                    else {
+                        expectError(retryResponse, vector.expected.status, ErrorCode.AUTH_INVALID, `${purpose} ${vector.name}`);
+                        assertEnrollmentErrorIsSecretFree(retryResponse, [initialPayload, retryPayload], `${purpose} ${vector.name}`);
+                    }
+                    assertStateDelta(beforeRetry, await environment.admin.observeAuthorityState(), {}, `${purpose} ${vector.name} retry`);
+                    invariant(same(await environment.admin.inspectEnrollmentPrincipal(principal, initial.client_id), {
+                        response_client_matches: true,
+                        active_credential_bindings: 1,
+                        bound_credential_matches_enrollment: true,
+                    }), `${purpose} ${vector.name} changed enrollment binding ownership.`);
+                }
+                catch (error) {
+                    retryVectorErrors.push(`${purpose} ${vector.name}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        invariant(retryVectorErrors.length === 0, retryVectorErrors.join(' | '));
+        await environment.admin.reset();
+        const ownerPrincipal = await environment.admin.createPrincipal('owner');
+        const ordinaryPrincipal = await environment.admin.createPrincipal('ordinary');
+        const ownerInvitation = await environment.admin.issueSingleUseInvitation(ownerPrincipal, 'owner');
+        const ordinaryInvitation = await environment.admin.issueSingleUseInvitation(ordinaryPrincipal, 'client');
+        const ownerCredential = `${'Q'.repeat(42)}U`;
+        const ordinaryCredential = `${'Y'.repeat(42)}U`;
+        const beforeAuthorityEnrollment = await environment.admin.observeAuthorityState();
+        const ownerResponse = await environment.operations.enroll(createProtocolEnvelope('owner-enroll', {
+            invitation: ownerInvitation,
+            retry_key: '00000000-0000-4000-8000-000000000211',
+            client_credential: ownerCredential,
+            client_name: 'owner-client',
+        }));
+        const ordinaryResponse = await environment.operations.enroll(createProtocolEnvelope('ordinary-enroll', {
+            invitation: ordinaryInvitation,
+            retry_key: '00000000-0000-4000-8000-000000000212',
+            client_credential: ordinaryCredential,
+            client_name: 'ordinary-client',
+        }));
+        expectStatus(ownerResponse, 201, 'Owner enrollment');
+        expectStatus(ordinaryResponse, 201, 'Ordinary enrollment');
+        const owner = decodeEnrollmentExchangeResponseEnvelope(ownerResponse.body).payload;
+        const ordinary = decodeEnrollmentExchangeResponseEnvelope(ordinaryResponse.body).payload;
+        invariant(owner.purpose === 'owner' && same(owner.server_capabilities, ['create_cube']), 'Owner enrollment lacked exact create-cube authority.');
+        invariant(ordinary.purpose === 'client' && ordinary.server_capabilities.length === 0, 'Ordinary enrollment gained authority.');
+        assertStateDelta(beforeAuthorityEnrollment, await environment.admin.observeAuthorityState(), { enrolled_clients: 2, enrollment_claims: 2, server_capabilities: 1 }, 'Owner and ordinary enrollment');
+        const cubeRequest = {
+            retry_key: '00000000-0000-4000-8000-000000000213',
+            name: 'repository-one',
+            template: 'default',
+        };
+        const droneCredential = await environment.admin.issueDroneSession(ownerPrincipal);
+        const beforeDeniedCreate = await environment.admin.observeAuthorityState();
+        expectSecretFreeError(await environment.operations.createCube(null, createProtocolEnvelope('cube-missing-auth', cubeRequest)), 401, ErrorCode.AUTH_MISSING, 'Missing-auth cube create', [cubeRequest.retry_key]);
+        expectSecretFreeError(await environment.operations.createCube('invalid-credential', createProtocolEnvelope('cube-invalid-auth', cubeRequest)), 401, ErrorCode.AUTH_INVALID, 'Invalid-auth cube create', [cubeRequest.retry_key]);
+        expectSecretFreeError(await environment.operations.createCube(ordinaryCredential, createProtocolEnvelope('cube-denied', cubeRequest)), 403, ErrorCode.ACCESS_DENIED, 'Ordinary cube create', [cubeRequest.retry_key]);
+        expectSecretFreeError(await environment.operations.createCube(droneCredential, createProtocolEnvelope('cube-drone-denied', cubeRequest)), 403, ErrorCode.ACCESS_DENIED, 'Drone-session cube create', [cubeRequest.retry_key]);
+        assertStateDelta(beforeDeniedCreate, await environment.admin.observeAuthorityState(), {}, 'Denied ordinary cube create');
+        const beforeCreate = await environment.admin.observeAuthorityState();
+        const createdResponse = await environment.operations.createCube(ownerCredential, createProtocolEnvelope('cube-create', cubeRequest));
+        expectStatus(createdResponse, 201, 'Owner cube create');
+        const created = decodeCreateCubeResponseEnvelope(createdResponse.body).payload;
+        assertStateDelta(beforeCreate, await environment.admin.observeAuthorityState(), { cubes: 1, roles: 2, grants: 1, cube_create_bindings: 1 }, 'Owner cube create');
+        invariant(same(await environment.admin.inspectCreatedCube(ownerPrincipal, created), {
+            cube_exists: true,
+            creator_has_grant: true,
+            grant_count: 1,
+            role_count: 2,
+            human_seat_role_matches: true,
+            default_worker_role_matches: true,
+        }), 'Created cube identities or creator grant did not match persisted authority state.');
+        const beforeCreateRetry = await environment.admin.observeAuthorityState();
+        const retriedCreateResponse = await environment.operations.createCube(ownerCredential, createProtocolEnvelope('cube-retry', cubeRequest));
+        expectStatus(retriedCreateResponse, 201, 'Exact cube-create retry');
+        invariant(same(decodeCreateCubeResponseEnvelope(retriedCreateResponse.body).payload, created), 'Exact cube-create retry returned different identities.');
+        assertStateDelta(beforeCreateRetry, await environment.admin.observeAuthorityState(), {}, 'Exact cube-create retry');
+        const beforeCreateMismatch = await environment.admin.observeAuthorityState();
+        expectSecretFreeError(await environment.operations.createCube(ownerCredential, createProtocolEnvelope('cube-mismatch', { ...cubeRequest, name: 'repository-two' })), 409, ErrorCode.INVALID_INPUT, 'Cube-create retry mismatch', [cubeRequest.retry_key]);
+        assertStateDelta(beforeCreateMismatch, await environment.admin.observeAuthorityState(), {}, 'Cube-create retry mismatch');
+        await environment.admin.grantCreateCubeCapability(ordinaryPrincipal);
+        const crossClientRequest = { ...cubeRequest, name: 'ordinary-repository' };
+        const beforeCrossClientCreate = await environment.admin.observeAuthorityState();
+        const crossClientResponse = await environment.operations.createCube(ordinaryCredential, createProtocolEnvelope('cube-cross-client', crossClientRequest));
+        expectStatus(crossClientResponse, 201, 'Cross-client cube create with reused retry key');
+        const crossClientCreated = decodeCreateCubeResponseEnvelope(crossClientResponse.body).payload;
+        invariant(crossClientCreated.cube_id !== created.cube_id, 'Cross-client retry key reused another client\'s cube.');
+        assertStateDelta(beforeCrossClientCreate, await environment.admin.observeAuthorityState(), { cubes: 1, roles: 2, grants: 1, cube_create_bindings: 1 }, 'Cross-client cube create');
+        invariant((await environment.admin.inspectCreatedCube(ordinaryPrincipal, crossClientCreated)).creator_has_grant, 'Cross-client cube creation did not grant its authenticated creator.');
+        const beforeCrossClientRetry = await environment.admin.observeAuthorityState();
+        const crossClientRetry = await environment.operations.createCube(ordinaryCredential, createProtocolEnvelope('cube-cross-client-retry', crossClientRequest));
+        expectStatus(crossClientRetry, 201, 'Exact cross-client cube-create retry');
+        invariant(same(decodeCreateCubeResponseEnvelope(crossClientRetry.body).payload, crossClientCreated), 'Exact cross-client cube-create retry returned different identities.');
+        assertStateDelta(beforeCrossClientRetry, await environment.admin.observeAuthorityState(), {}, 'Exact cross-client cube-create retry');
+        const beforeSecondCreate = await environment.admin.observeAuthorityState();
+        const secondCreatedResponse = await environment.operations.createCube(ownerCredential, createProtocolEnvelope('cube-create-second', {
+            ...cubeRequest,
+            retry_key: '00000000-0000-4000-8000-000000000214',
+            name: 'repository-two',
+        }));
+        expectStatus(secondCreatedResponse, 201, 'Second cube create');
+        const secondCreated = decodeCreateCubeResponseEnvelope(secondCreatedResponse.body).payload;
+        invariant(secondCreated.cube_id !== created.cube_id, 'Fresh cube-create retry key reused an existing cube.');
+        assertStateDelta(beforeSecondCreate, await environment.admin.observeAuthorityState(), { cubes: 1, roles: 2, grants: 1, cube_create_bindings: 1 }, 'Second cube create');
+        await environment.admin.revokePrincipal(ownerPrincipal);
+        const beforeRevokedCreate = await environment.admin.observeAuthorityState();
+        expectSecretFreeError(await environment.operations.createCube(ownerCredential, createProtocolEnvelope('cube-revoked', {
+            ...cubeRequest,
+            retry_key: '00000000-0000-4000-8000-000000000215',
+        })), 401, ErrorCode.SESSION_REVOKED, 'Revoked owner cube create', ['00000000-0000-4000-8000-000000000215']);
+        assertStateDelta(beforeRevokedCreate, await environment.admin.observeAuthorityState(), {}, 'Revoked owner cube create');
+        await environment.admin.reset();
+        principalA = await environment.admin.createPrincipal('principal-a');
+        principalB = await environment.admin.createPrincipal('principal-b');
+        cubeA = await environment.admin.createCube('cube-a');
+        cubeB = await environment.admin.createCube('cube-b');
+        await environment.admin.grantCube(principalA, cubeA);
+        await environment.admin.grantCube(principalB, cubeB);
+        const invitationA = await environment.admin.issueSingleUseInvitation(principalA, 'client');
+        const invitationB = await environment.admin.issueSingleUseInvitation(principalB, 'client');
+        credentialA = 'A'.repeat(43);
+        credentialB = 'E'.repeat(43);
         const enrollmentARequest = createProtocolEnvelope('enroll-a1', {
             invitation: invitationA,
+            retry_key: '00000000-0000-4000-8000-000000000201',
+            client_credential: credentialA,
             client_name: 'conformance-a',
         });
         const enrollmentBRequest = createProtocolEnvelope('enroll-b1', {
             invitation: invitationB,
+            retry_key: '00000000-0000-4000-8000-000000000202',
+            client_credential: credentialB,
             client_name: 'conformance-b',
         });
         const enrolledAResponse = await environment.operations.enroll(enrollmentARequest);
         const enrolledBResponse = await environment.operations.enroll(enrollmentBRequest);
         expectStatus(enrolledAResponse, 201, 'Principal A enrollment');
         expectStatus(enrolledBResponse, 201, 'Principal B enrollment');
-        credentialA = decodeEnrollmentExchangeResponseEnvelope(enrolledAResponse.body).payload.credential;
-        credentialB = decodeEnrollmentExchangeResponseEnvelope(enrolledBResponse.body).payload.credential;
-        invariant(credentialA !== credentialB, 'Enrollment issued the same credential to two principals.');
-        expectError(await environment.operations.enroll(enrollmentARequest), 401, ErrorCode.AUTH_INVALID, 'Invitation reuse');
-        const protocolResponse = await environment.operations.protocol(credentialA);
-        expectStatus(protocolResponse, 200, 'Authenticated protocol request');
-        protocolBody = protocolResponse.body;
-        protocolInfo = negotiateProtocol(decodeProtocolInfoEnvelope(protocolBody).payload, [
-            'log.cursor',
-            'stream.sse',
-            'stream.replay',
-            'acks',
-            'claims',
-            'decisions',
-        ]);
+        const enrolledA = decodeEnrollmentExchangeResponseEnvelope(enrolledAResponse.body).payload;
+        const enrolledB = decodeEnrollmentExchangeResponseEnvelope(enrolledBResponse.body).payload;
+        invariant(enrolledA.purpose === 'client' && enrolledB.purpose === 'client', 'Ordinary enrollment returned owner authority.');
+        invariant(enrolledA.server_capabilities.length === 0 && enrolledB.server_capabilities.length === 0, 'Ordinary enrollment returned a server capability.');
+        invariant(!('credential' in enrolledA) && !('credential' in enrolledB), 'Enrollment response returned a bearer.');
+        const retriedAResponse = await environment.operations.enroll(enrollmentARequest);
+        expectStatus(retriedAResponse, 201, 'Exact enrollment retry');
+        invariant(JSON.stringify(decodeEnrollmentExchangeResponseEnvelope(retriedAResponse.body).payload) ===
+            JSON.stringify(enrolledA), 'Exact enrollment retry returned different identities.');
+        expectError(await environment.operations.enroll(createProtocolEnvelope('enroll-a-mismatch', {
+            ...enrollmentARequest.payload,
+            retry_key: '00000000-0000-4000-8000-000000000203',
+        })), 401, ErrorCode.AUTH_INVALID, 'Enrollment retry mismatch');
         return {
-            unauthenticated: ErrorCode.AUTH_MISSING,
             enrollment_status: 201,
-            invitation_reuse: ErrorCode.AUTH_INVALID,
-            protocol_version: protocolInfo.protocol_version,
+            exact_retry_status: 201,
+            mismatched_retry: ErrorCode.AUTH_INVALID,
+            response_secret_free: true,
         };
     });
     await record('security.adapter-boundary-injection', async () => {
-        invariant(protocolInfo, 'Protocol fixture did not produce request limits.');
         const injectedMessage = "'); DROP TABLE log_entries; --\r\ndata: forged-sse-frame";
         const injectedBody = JSON.stringify(createProtocolEnvelope('inject-b1', { message: injectedMessage }));
-        invariant(utf8ByteLength(injectedBody) <= protocolInfo.limits.max_request_bytes &&
-            utf8ByteLength(injectedMessage) <= protocolInfo.limits.max_log_message_bytes, 'Injection fixture exceeded an advertised request limit.');
+        invariant(utf8ByteLength(injectedBody) <= PROTOCOL_LIMIT_CEILINGS.max_request_bytes &&
+            utf8ByteLength(injectedMessage) <= PROTOCOL_LIMIT_CEILINGS.max_log_message_bytes, 'Injection fixture exceeded the shared request-limit ceiling.');
         const injected = await environment.operations.appendRaw(credentialB, cubeB, injectedBody);
         expectStatus(injected, 201, 'Adapter-boundary injection append');
         const injectedEntry = decodeAppendLogResultEnvelope(injected.body).payload.entry;
@@ -229,10 +406,9 @@ export async function runAdapterConformance(environment, options = {}) {
         };
     });
     await record('security.oversize-request', async () => {
-        invariant(protocolInfo, 'Protocol fixture did not produce request limits.');
         const baseBody = JSON.stringify(createProtocolEnvelope('oversize-a1', { message: 'must-not-persist' }));
-        const oversizedBody = baseBody + ' '.repeat(Math.max(0, protocolInfo.limits.max_request_bytes - utf8ByteLength(baseBody) + 1));
-        invariant(utf8ByteLength(oversizedBody) > protocolInfo.limits.max_request_bytes, 'Oversize fixture did not exceed max_request_bytes.');
+        const oversizedBody = baseBody + ' '.repeat(Math.max(0, PROTOCOL_LIMIT_CEILINGS.max_request_bytes - utf8ByteLength(baseBody) + 1));
+        invariant(utf8ByteLength(oversizedBody) > PROTOCOL_LIMIT_CEILINGS.max_request_bytes, 'Oversize fixture did not exceed max_request_bytes.');
         const response = await environment.operations.appendRaw(credentialA, cubeA, oversizedBody);
         expectError(response, 413, ErrorCode.CONTENT_TOO_LARGE, 'Oversized append request');
         const read = await environment.operations.read(credentialA, cubeA, createProtocolEnvelope('oversize-read', { cursor: null, limit: 10 }));
@@ -353,21 +529,6 @@ export async function runAdapterConformance(environment, options = {}) {
         invariant(second.supersedes === first.id, 'Superseding decision did not reference its predecessor.');
         return { active_count: 1, active_decision: 'second', supersedes_first: true };
     });
-    await record('capabilities.unsupported-fails-closed', async () => {
-        invariant(protocolBody, 'Protocol fixture did not produce an envelope.');
-        let code = null;
-        try {
-            negotiateProtocol(decodeProtocolInfoEnvelope(protocolBody).payload, ['future.required']);
-        }
-        catch (error) {
-            if (error instanceof ProtocolContractError)
-                code = error.code;
-            else
-                throw error;
-        }
-        invariant(code === ErrorCode.UNSUPPORTED_CAPABILITY, 'Unsupported capability did not fail closed client-side.');
-        return { code };
-    });
     await record('security.active-stream-revocation', async () => {
         invariant(liveCursor, 'Stream fixture did not produce a live cursor.');
         const opened = await environment.operations.openStream(credentialA, cubeA, liveCursor);