@modelprofile.com/browser-runtime 1.0.1 → 2.1.0

package/ts/classes.runtime.ts

@@ -10,19 +10,27 @@ import {
 } from './internal.testing.js';
 import type {
   IAttachTrustedFramedPeerOptions,
+  IApplyBrowserAttachmentBindingRequest,
+  IBrowserAttachmentBinding,
   IBrowserActionStateResult,
   IBrowserArtifactMetadata,
-  IBrowserCapabilityDescriptor,
+  TBrowserCapabilityDescriptor,
+  TBrowserCapabilityAuthorizationRequest,
   IBrowserConfinementProbeContext,
   IBrowserObservationResult,
-  IBrowserRuntimeAuditEvent,
+  TBrowserRuntimeAuditEvent,
+  TBrowserRuntimeOperationIdentity,
   IBrowserRuntimeFrameSubscription,
   IBrowserRuntimeOperationOptions,
   IBrowserRuntimeOptions,
+  IBrowserResourceRegistration,
   IBrowserRuntimeState,
   IBrowserScreenshotResult,
-  IIssueBrowserCapabilityRequest,
-  IIssuedBrowserCapability,
+  ICreateBrowserResourceRequest,
+  TQualifiedBrowserSessionId,
+  IRegisterBrowserResourceRequest,
+  TIssueBrowserCapabilityRequest,
+  TIssuedBrowserCapability,
   ILiveBrowserSessionLike,
   TBrowserActorRole,
   TBrowserAgentAction,
@@ -46,32 +54,43 @@ import { BrowserRuntimeFramedServerPeer } from './classes.framed.js';
 interface INormalizedRuntimeOptions {
   runtimeDirectory: string;
   authorizeCapability: IBrowserRuntimeOptions['authorizeCapability'];
+  beforeOperation?: IBrowserRuntimeOptions['beforeOperation'];
   audit?: IBrowserRuntimeOptions['audit'];
   sessionFactory: (
     options: plugins.smartpuppeteer.ILiveBrowserSessionOptions,
   ) => ILiveBrowserSessionLike;
   confinementProbe: (context: IBrowserConfinementProbeContext) => Promise<void>;
   environment: { platform: NodeJS.Platform; uid: number | undefined };
-  maxProjectSlots: number;
+  maxResources: number;
+  maxResourcesPerProject: number;
+  maxRunningResources: number;
+  maxRunningResourcesPerProject: number;
   maxCapabilities: number;
+  maxCapabilitiesPerResource: number;
   maxCapabilitiesPerProject: number;
   capabilityDefaultTtlMs: number;
   capabilityMaximumTtlMs: number;
   authorizationTimeoutMs: number;
-  maxTabsPerProject: number;
+  beforeOperationTimeoutMs: number;
+  maxTabsPerResource: number;
   operationTimeoutMs: number;
   quiescenceTimeoutMs: number;
   terminationGraceMs: number;
   terminationForceMs: number;
   auditTimeoutMs: number;
   confinementProbeTimeoutMs: number;
-  idleRetirementMs: number;
+  idleTerminationMs: number;
   maxFrameBytes: number;
   frameAcknowledgementTimeoutMs: number;
   egress: NonNullable<IBrowserRuntimeOptions['egress']>;
+  beforeLeasePublication?: IBrowserRuntimeTestingOptions['beforeLeasePublication'];
+  beforeIdleTermination?: IBrowserRuntimeTestingOptions['beforeIdleTermination'];
+  beforeFrameFailureTermination?: IBrowserRuntimeTestingOptions['beforeFrameFailureTermination'];
+  afterFrameFailureFence?: IBrowserRuntimeTestingOptions['afterFrameFailureFence'];
+  beforeFramedPeerLeasePublication?: IBrowserRuntimeTestingOptions['beforeFramedPeerLeasePublication'];
 }
 
-interface ICapabilityRecord extends IBrowserCapabilityDescriptor {
+type TCapabilityRecord = TBrowserCapabilityDescriptor & {
   digest: plugins.Buffer;
   state: 'active' | 'revoked' | 'expired';
   expiryTimer: ReturnType<typeof setTimeout>;
@@ -82,19 +101,21 @@ interface ICapabilityRecord extends IBrowserCapabilityDescriptor {
   revocationComplete?: boolean;
   leaseCleanupComplete?: boolean;
   disconnectComplete?: boolean;
-}
+  revoking?: boolean;
+};
 
 interface ILeaseRecord {
   leaseId: string;
-  capability: ICapabilityRecord;
+  capability: TCapabilityRecord;
   digest: plugins.Buffer;
   peerId: string;
   role: TBrowserActorRole;
-  slot: IProjectSlot;
+  slot: IResourceSlot;
   controller: AbortController;
   released: boolean;
   releasePromise?: Promise<void>;
   releaseGeneration?: number;
+  releaseOwnsFence?: boolean;
 }
 
 interface IOperationRecord {
@@ -103,6 +124,8 @@ interface IOperationRecord {
   controller: AbortController;
   action: string;
   startedAt: number;
+  session: ILiveBrowserSessionLike;
+  incarnationGeneration: number;
   promise: Promise<void>;
 }
 
@@ -116,12 +139,19 @@ interface IFrameSubscriptionRecord {
   closed: boolean;
 }
 
-interface IProjectSlot {
+interface IResourceSlot {
   projectId: string;
+  browserResourceId: string;
+  registeredAt: number;
+  attachmentBinding: IBrowserAttachmentBinding;
   mutex: TransitionMutex;
-  generation: number;
+  arbitrationGeneration: number;
+  incarnationGeneration: number;
   fencingGeneration?: number;
   permanentlyFenced: boolean;
+  retirementPending: boolean;
+  attachmentFenceCount: number;
+  attachmentRetryBinding?: IBrowserAttachmentBinding;
   session?: ILiveBrowserSessionLike;
   proxy?: BrowserEgressProxy;
   profileDirectory?: string;
@@ -130,21 +160,21 @@ interface IProjectSlot {
   operation?: IOperationRecord;
   frameSubscription?: IFrameSubscriptionRecord;
   idleTimer?: ReturnType<typeof setTimeout>;
+  lifecycleTail: Promise<void>;
+  lifecycleOperationCount: number;
+  terminationRequestGeneration: number;
+  terminationFenceGeneration?: number;
+  terminatePromise?: Promise<void>;
+  retirePromise?: Promise<void>;
+  attachmentOperations: Map<string, Promise<IBrowserResourceRegistration>>;
 }
 
-export interface IAcquireBrowserRuntimeLeaseOptions {
+export type TAcquireBrowserRuntimeLeaseOptions = TBrowserCapabilityAuthorizationRequest & {
   capabilityToken: string;
-  peerId: string;
-  expectedRole?: TBrowserActorRole;
-  expectedSource?: TBrowserCapabilitySource;
-  scopeId?: string;
-  sessionId?: string;
   signal?: AbortSignal;
-}
+};
 
-const projectIdMaximum = 128;
-const actorIdMaximum = 128;
-const peerIdMaximum = 128;
+const identifierMaximum = 256;
 
 export class BrowserRuntime {
   private readonly options: INormalizedRuntimeOptions;
@@ -152,10 +182,12 @@ export class BrowserRuntime {
   private readonly artifactRoot: string;
   private readonly lockPath: string;
   private readonly artifactStore: BrowserArtifactStore;
-  private readonly slots = new Map<string, IProjectSlot>();
-  private readonly capabilitiesByDigest = new Map<string, ICapabilityRecord>();
-  private readonly capabilitiesById = new Map<string, ICapabilityRecord>();
-  private readonly failedRevocations = new Set<ICapabilityRecord>();
+  private readonly slots = new Map<string, IResourceSlot>();
+  private readonly retiredResourceIds = new Uint8Array(64 * 1024);
+  private readonly retiredResourceKeys = new Uint8Array(64 * 1024);
+  private readonly capabilitiesByDigest = new Map<string, TCapabilityRecord>();
+  private readonly capabilitiesById = new Map<string, TCapabilityRecord>();
+  private readonly failedRevocations = new Set<TCapabilityRecord>();
   private readonly capabilityMutex = new TransitionMutex();
   private readonly cleanupOperations = new Set<Promise<void>>();
   private readonly framedPeers = new Set<BrowserRuntimeFramedServerPeer>();
@@ -168,6 +200,9 @@ export class BrowserRuntime {
   private lifecycleController = new AbortController();
   private pendingCapabilities = 0;
   private readonly pendingCapabilitiesByProject = new Map<string, number>();
+  private readonly pendingCapabilitiesByResource = new Map<string, number>();
+  private pendingLaunches = 0;
+  private readonly pendingLaunchesByProject = new Map<string, number>();
 
   constructor(options: IBrowserRuntimeOptions | IBrowserRuntimeTestingOptions) {
     if (!options || typeof options !== 'object') {
@@ -182,6 +217,9 @@ export class BrowserRuntime {
     if (options.audit !== undefined && typeof options.audit !== 'function') {
       throw new BrowserRuntimeError('INVALID_INPUT', 'audit must be a function');
     }
+    if (options.beforeOperation !== undefined && typeof options.beforeOperation !== 'function') {
+      throw new BrowserRuntimeError('INVALID_INPUT', 'beforeOperation must be a function');
+    }
     const testingOptions = browserRuntimeTesting in options
       && options[browserRuntimeTesting] === true
       ? options as IBrowserRuntimeTestingOptions
@@ -214,19 +252,41 @@ export class BrowserRuntime {
     this.options = {
       runtimeDirectory: options.runtimeDirectory,
       authorizeCapability: options.authorizeCapability,
+      beforeOperation: options.beforeOperation,
       audit: options.audit,
       sessionFactory: testingOptions?.sessionFactory ?? ((sessionOptions) => (
         new plugins.smartpuppeteer.LiveBrowserSession(sessionOptions)
       )),
       confinementProbe: testingOptions?.confinementProbe ?? runProductionConfinementProbe,
       environment,
-      maxProjectSlots: validateOptionalInteger(
-        options.maxProjectSlots,
-        'maxProjectSlots',
+      maxResources: validateOptionalInteger(
+        options.maxResources,
+        'maxResources',
+        1,
+        4096,
+        256,
+      ),
+      maxResourcesPerProject: validateOptionalInteger(
+        options.maxResourcesPerProject,
+        'maxResourcesPerProject',
+        1,
+        1024,
+        64,
+      ),
+      maxRunningResources: validateOptionalInteger(
+        options.maxRunningResources,
+        'maxRunningResources',
         1,
         256,
         32,
       ),
+      maxRunningResourcesPerProject: validateOptionalInteger(
+        options.maxRunningResourcesPerProject,
+        'maxRunningResourcesPerProject',
+        1,
+        128,
+        16,
+      ),
       maxCapabilities: validateOptionalInteger(
         options.maxCapabilities,
         'maxCapabilities',
@@ -234,6 +294,13 @@ export class BrowserRuntime {
         4096,
         512,
       ),
+      maxCapabilitiesPerResource: validateOptionalInteger(
+        options.maxCapabilitiesPerResource,
+        'maxCapabilitiesPerResource',
+        1,
+        512,
+        64,
+      ),
       maxCapabilitiesPerProject: validateOptionalInteger(
         options.maxCapabilitiesPerProject,
         'maxCapabilitiesPerProject',
@@ -250,9 +317,16 @@ export class BrowserRuntime {
         120_000,
         10_000,
       ),
-      maxTabsPerProject: validateOptionalInteger(
-        options.maxTabsPerProject,
-        'maxTabsPerProject',
+      beforeOperationTimeoutMs: validateOptionalInteger(
+        options.beforeOperationTimeoutMs,
+        'beforeOperationTimeoutMs',
+        100,
+        120_000,
+        10_000,
+      ),
+      maxTabsPerResource: validateOptionalInteger(
+        options.maxTabsPerResource,
+        'maxTabsPerResource',
         1,
         256,
         32,
@@ -299,9 +373,9 @@ export class BrowserRuntime {
         60_000,
         10_000,
       ),
-      idleRetirementMs: validateOptionalInteger(
-        options.idleRetirementMs,
-        'idleRetirementMs',
+      idleTerminationMs: validateOptionalInteger(
+        options.idleTerminationMs,
+        'idleTerminationMs',
         1000,
         24 * 60 * 60 * 1000,
         15 * 60_000,
@@ -321,6 +395,11 @@ export class BrowserRuntime {
         10_000,
       ),
       egress: options.egress ?? {},
+      beforeLeasePublication: testingOptions?.beforeLeasePublication,
+      beforeIdleTermination: testingOptions?.beforeIdleTermination,
+      beforeFrameFailureTermination: testingOptions?.beforeFrameFailureTermination,
+      afterFrameFailureFence: testingOptions?.afterFrameFailureFence,
+      beforeFramedPeerLeasePublication: testingOptions?.beforeFramedPeerLeasePublication,
     };
     this.profileRoot = plugins.path.join(options.runtimeDirectory, 'profiles');
     this.artifactRoot = plugins.path.join(options.runtimeDirectory, 'artifacts');
@@ -373,21 +452,174 @@ export class BrowserRuntime {
     return this.stopPromise;
   }
 
+  public createResource(requestArg: ICreateBrowserResourceRequest): IBrowserResourceRegistration {
+    this.requireRunning();
+    if (!requestArg || typeof requestArg !== 'object') throw new BrowserRuntimeError('INVALID_INPUT');
+    const projectId = this.validateIdentifier(requestArg.projectId, 'projectId');
+    const attachmentBinding = this.validateAttachmentBinding(requestArg.attachmentBinding);
+    let browserResourceId: string;
+    do {
+      browserResourceId = randomId(24);
+    } while (this.slots.has(this.resourceKey(projectId, browserResourceId)));
+    return this.registerResource({ projectId, browserResourceId, attachmentBinding });
+  }
+
+  public registerResource(
+    requestArg: IRegisterBrowserResourceRequest,
+  ): IBrowserResourceRegistration {
+    this.requireRunning();
+    if (!requestArg || typeof requestArg !== 'object') throw new BrowserRuntimeError('INVALID_INPUT');
+    const projectId = this.validateIdentifier(requestArg.projectId, 'projectId');
+    const browserResourceId = this.validateResourceId(requestArg.browserResourceId);
+    const attachmentBinding = this.validateAttachmentBinding(requestArg.attachmentBinding);
+    const key = this.resourceKey(projectId, browserResourceId);
+    if (this.hasRetiredTombstone(this.retiredResourceIds, browserResourceId)) {
+      throw new BrowserRuntimeError('RESOURCE_RETIRED');
+    }
+    const existing = this.slots.get(key);
+    if (existing) {
+      if (!this.bindingsEqual(existing.attachmentBinding, attachmentBinding)) {
+        throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+      }
+      return this.describeResource(existing);
+    }
+    if ([...this.slots.values()].some((slot) => (
+      slot.browserResourceId === browserResourceId && slot.projectId !== projectId
+    ))) throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+    const projectResources = [...this.slots.values()].filter((slot) => (
+      slot.projectId === projectId
+    )).length;
+    if (
+      this.slots.size >= this.options.maxResources
+      || projectResources >= this.options.maxResourcesPerProject
+    ) throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+    const slot: IResourceSlot = {
+      projectId,
+      browserResourceId,
+      registeredAt: Date.now(),
+      attachmentBinding,
+      mutex: new TransitionMutex(),
+      arbitrationGeneration: 0,
+      incarnationGeneration: 0,
+      permanentlyFenced: false,
+      retirementPending: false,
+      attachmentFenceCount: 0,
+      lifecycleTail: Promise.resolve(),
+      lifecycleOperationCount: 0,
+      terminationRequestGeneration: 0,
+      attachmentOperations: new Map(),
+    };
+    this.slots.set(key, slot);
+    return this.describeResource(slot);
+  }
+
+  public listResources(): IBrowserResourceRegistration[] {
+    this.requireRunning();
+    return [...this.slots.values()].map((slot) => this.describeResource(slot));
+  }
+
+  public async applyAttachmentBinding(
+    requestArg: IApplyBrowserAttachmentBindingRequest,
+  ): Promise<IBrowserResourceRegistration> {
+    this.requireRunning();
+    const slot = this.resolveResourceRequest(requestArg);
+    const binding = this.validateAttachmentBinding(requestArg.attachmentBinding);
+    const operationKey = this.attachmentBindingKey(binding);
+    const existingOperation = slot.attachmentOperations.get(operationKey);
+    if (existingOperation) return existingOperation;
+    if (slot.attachmentOperations.size > 0) throw new BrowserRuntimeError('BUSY');
+    if (
+      slot.attachmentRetryBinding
+      && !this.bindingsEqual(binding, slot.attachmentRetryBinding)
+    ) throw new BrowserRuntimeError('BUSY');
+    const currentBinding = slot.attachmentBinding;
+    if (binding.attachmentRevision < currentBinding.attachmentRevision) {
+      throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+    }
+    if (
+      binding.attachmentRevision === currentBinding.attachmentRevision
+      && !slot.attachmentRetryBinding
+    ) {
+      if (!this.bindingsEqual(binding, currentBinding)) {
+        throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+      }
+      return this.describeResource(slot);
+    }
+    if (slot.retirementPending) throw new BrowserRuntimeError('RESOURCE_RETIRED');
+    slot.attachmentFenceCount += 1;
+    const operation = this.enqueueResourceLifecycle(slot, async () => (
+      this.applyAttachmentBindingInternal(slot, binding)
+    )).finally(() => {
+      slot.attachmentFenceCount = Math.max(0, slot.attachmentFenceCount - 1);
+      slot.attachmentOperations.delete(operationKey);
+    });
+    slot.attachmentOperations.set(operationKey, operation);
+    return operation;
+  }
+
+  public terminateResource(projectIdArg: string, browserResourceIdArg: string): Promise<void> {
+    this.requireRunning();
+    const slot = this.getRegisteredSlot(projectIdArg, browserResourceIdArg);
+    if (slot.retirePromise) return slot.retirePromise;
+    if (slot.terminatePromise) return slot.terminatePromise;
+    const terminationFenceGeneration = slot.terminationFenceGeneration
+      ?? ++slot.terminationRequestGeneration;
+    slot.terminationFenceGeneration = terminationFenceGeneration;
+    const lifecycleOperation = this.enqueueResourceLifecycle(slot, async () => {
+      await this.terminateRegisteredResourceInternal(slot, false);
+    });
+    const operation = lifecycleOperation.then(() => {
+      if (slot.terminationFenceGeneration === terminationFenceGeneration) {
+        slot.terminationFenceGeneration = undefined;
+      }
+    }).finally(() => {
+      if (slot.terminatePromise === operation) slot.terminatePromise = undefined;
+    });
+    slot.terminatePromise = operation;
+    return operation;
+  }
+
+  public retireResource(projectIdArg: string, browserResourceIdArg: string): Promise<void> {
+    this.requireRunning();
+    const slot = this.getRegisteredSlot(projectIdArg, browserResourceIdArg);
+    if (slot.retirePromise) return slot.retirePromise;
+    slot.retirementPending = true;
+    this.addRetiredTombstone(this.retiredResourceKeys, this.resourceKey(
+      slot.projectId,
+      slot.browserResourceId,
+    ));
+    this.addRetiredTombstone(this.retiredResourceIds, slot.browserResourceId);
+    const operation = this.enqueueResourceLifecycle(slot, async () => {
+      await this.retireRegisteredResourceInternal(slot);
+    }).finally(() => {
+      if (slot.retirePromise === operation) slot.retirePromise = undefined;
+    });
+    slot.retirePromise = operation;
+    return operation;
+  }
+
   public async issueCapability(
-    requestArg: IIssueBrowserCapabilityRequest,
-  ): Promise<IIssuedBrowserCapability> {
+    requestArg: TIssueBrowserCapabilityRequest,
+  ): Promise<TIssuedBrowserCapability> {
     this.requireRunning();
     if (!requestArg || typeof requestArg !== 'object') {
       throw new BrowserRuntimeError('INVALID_INPUT');
     }
-    const projectId = validateBoundedString(
-      requestArg.projectId,
-      'projectId',
-      1,
-      projectIdMaximum,
+    const projectId = this.validateIdentifier(requestArg.projectId, 'projectId');
+    const browserResourceId = this.validateResourceId(requestArg.browserResourceId);
+    const slot = this.getRegisteredSlot(projectId, browserResourceId);
+    const attachmentAuthorityId = this.validateIdentifier(
+      requestArg.attachmentAuthorityId,
+      'attachmentAuthorityId',
+    );
+    const attachmentRevision = validateInteger(
+      requestArg.attachmentRevision,
+      'attachmentRevision',
+      0,
+      Number.MAX_SAFE_INTEGER,
     );
-    const actorId = validateBoundedString(requestArg.actorId, 'actorId', 1, actorIdMaximum);
-    const peerId = validateBoundedString(requestArg.peerId, 'peerId', 1, peerIdMaximum);
+    const actorId = this.validateIdentifier(requestArg.actorId, 'actorId');
+    const peerId = this.validateIdentifier(requestArg.peerId, 'peerId');
     const role = this.validateRole(requestArg.role);
     const source = this.validateSource(requestArg.source);
     if (
@@ -402,14 +634,41 @@ export class BrowserRuntime {
     const disconnect = requestArg.disconnect;
     const scopeId = requestArg.scopeId === undefined
       ? undefined
-      : validateBoundedString(requestArg.scopeId, 'scopeId', 1, 128);
+      : this.validateIdentifier(requestArg.scopeId, 'scopeId');
+    const channelId = requestArg.channelId === undefined
+      ? undefined
+      : this.validateIdentifier(requestArg.channelId, 'channelId');
     const sessionId = requestArg.sessionId === undefined
       ? undefined
-      : validateBoundedString(requestArg.sessionId, 'sessionId', 1, 128);
+      : this.validateQualifiedSessionId(requestArg.sessionId);
     if (
-      (source === 'flex' && (!scopeId || !sessionId))
-      || (source !== 'flex' && (scopeId !== undefined || sessionId !== undefined))
+      (role === 'agent' && !sessionId)
+      || (role === 'human' && sessionId !== undefined)
+      || (source === 'flex' && (!scopeId || !channelId || sessionId?.harnessId !== 'flex'))
+      || (source === 'mcp' && (scopeId !== undefined || channelId !== undefined
+        || sessionId?.harnessId !== 'opencode'))
+      || (source === 'human' && (scopeId !== undefined || channelId !== undefined))
     ) throw new BrowserRuntimeError('INVALID_INPUT');
+    const authority = this.validateExpectedCapabilityBinding({
+      projectId,
+      browserResourceId,
+      attachmentAuthorityId,
+      attachmentRevision,
+      actorId,
+      role,
+      peerId,
+      source,
+      ...(scopeId ? { scopeId } : {}),
+      ...(channelId ? { channelId } : {}),
+      ...(sessionId ? { sessionId } : {}),
+    } as TBrowserCapabilityAuthorizationRequest);
+    this.assertCapabilityBinding(slot, {
+      attachmentAuthorityId,
+      attachmentRevision,
+      role,
+      sessionId,
+    });
+    this.assertSlotAvailable(slot);
     const expiresInMs = requestArg.expiresInMs === undefined
       ? this.options.capabilityDefaultTtlMs
       : validateInteger(
@@ -420,16 +679,21 @@ export class BrowserRuntime {
         );
 
     const lifecycleEpoch = this.lifecycleEpoch;
+    const resourceKey = this.resourceKey(projectId, browserResourceId);
     const pendingForProject = this.pendingCapabilitiesByProject.get(projectId) ?? 0;
-    const activeForProject = [...this.capabilitiesById.values()].filter((record) => (
-      record.projectId === projectId && record.state === 'active'
+    const pendingForResource = this.pendingCapabilitiesByResource.get(resourceKey) ?? 0;
+    const recordedForProject = [...this.capabilitiesById.values()].filter((record) => (
+      record.projectId === projectId
     )).length;
+    const recordedForResource = this.capabilitiesForResource(slot).length;
     if (
       this.pendingCapabilities + this.capabilitiesById.size >= this.options.maxCapabilities
-      || pendingForProject + activeForProject >= this.options.maxCapabilitiesPerProject
+      || pendingForProject + recordedForProject >= this.options.maxCapabilitiesPerProject
+      || pendingForResource + recordedForResource >= this.options.maxCapabilitiesPerResource
     ) throw new BrowserRuntimeError('QUOTA_EXCEEDED');
     this.pendingCapabilities += 1;
     this.pendingCapabilitiesByProject.set(projectId, pendingForProject + 1);
+    this.pendingCapabilitiesByResource.set(resourceKey, pendingForResource + 1);
     let authorized = false;
     const authorizationController = new AbortController();
     const authorizationSignal = AbortSignal.any([
@@ -437,15 +701,10 @@ export class BrowserRuntime {
       this.lifecycleController.signal,
     ]);
     try {
-      const authorization = Promise.resolve(this.options.authorizeCapability({
-        projectId,
-        actorId,
-        role,
-        peerId,
-        source,
-        ...(scopeId ? { scopeId } : {}),
-        ...(sessionId ? { sessionId } : {}),
-      }, authorizationSignal));
+      const authorization = Promise.resolve(this.options.authorizeCapability(
+        authority,
+        authorizationSignal,
+      ));
       const result = await waitBounded(authorization, this.options.authorizationTimeoutMs);
       if (!result.settled) {
         authorizationController.abort(new BrowserRuntimeError('TIMEOUT'));
@@ -460,25 +719,48 @@ export class BrowserRuntime {
       const remaining = (this.pendingCapabilitiesByProject.get(projectId) ?? 1) - 1;
       if (remaining > 0) this.pendingCapabilitiesByProject.set(projectId, remaining);
       else this.pendingCapabilitiesByProject.delete(projectId);
+      const resourceRemaining = (this.pendingCapabilitiesByResource.get(resourceKey) ?? 1) - 1;
+      if (resourceRemaining > 0) {
+        this.pendingCapabilitiesByResource.set(resourceKey, resourceRemaining);
+      } else {
+        this.pendingCapabilitiesByResource.delete(resourceKey);
+      }
     }
     if (authorized !== true) throw new BrowserRuntimeError('AUTHORIZATION_DENIED');
     this.requireRunning();
     if (this.lifecycleEpoch !== lifecycleEpoch) throw new BrowserRuntimeError('ABORTED');
+    const slotAfterAuthorization = this.getRegisteredSlot(projectId, browserResourceId);
+    this.assertCapabilityBinding(slotAfterAuthorization, {
+      attachmentAuthorityId,
+      attachmentRevision,
+      role,
+      sessionId,
+    });
+    this.assertSlotAvailable(slotAfterAuthorization);
 
     const release = await this.capabilityMutex.acquire();
     try {
       this.requireRunning();
       if (this.lifecycleEpoch !== lifecycleEpoch) throw new BrowserRuntimeError('ABORTED');
+      const currentSlot = this.getRegisteredSlot(projectId, browserResourceId);
+      this.assertCapabilityBinding(currentSlot, {
+        attachmentAuthorityId,
+        attachmentRevision,
+        role,
+        sessionId,
+      });
+      this.assertSlotAvailable(currentSlot);
       const activeProjectCapabilities = [...this.capabilitiesById.values()].filter((record) => (
-        record.projectId === projectId && record.state === 'active'
+        record.projectId === projectId
       )).length;
+      const activeResourceCapabilities = this.capabilitiesForResource(currentSlot).length;
       if (
         this.capabilitiesById.size >= this.options.maxCapabilities
         || activeProjectCapabilities >= this.options.maxCapabilitiesPerProject
+        || activeResourceCapabilities >= this.options.maxCapabilitiesPerResource
       ) {
         throw new BrowserRuntimeError('QUOTA_EXCEEDED');
       }
-      this.getOrCreateSlot(projectId);
       let capabilityToken: string;
       let digest: plugins.Buffer;
       let digestKey: string;
@@ -489,20 +771,14 @@ export class BrowserRuntime {
       } while (this.capabilitiesByDigest.has(digestKey));
       const capabilityId = randomId(18);
       const expiresAt = Date.now() + expiresInMs;
-      let record: ICapabilityRecord;
+      let record: TCapabilityRecord;
       const expiryTimer = setTimeout(() => {
         if (record.state === 'active') record.state = 'expired';
         this.trackCleanup(this.revokeCapabilityRecord(record));
       }, expiresInMs);
       record = {
+        ...authority,
         capabilityId,
-        projectId,
-        actorId,
-        role,
-        peerId,
-        source,
-        ...(scopeId ? { scopeId } : {}),
-        ...(sessionId ? { sessionId } : {}),
         expiresAt,
         digest,
         state: 'active',
@@ -513,14 +789,8 @@ export class BrowserRuntime {
       this.capabilitiesByDigest.set(digestKey, record);
       this.capabilitiesById.set(capabilityId, record);
       return {
+        ...authority,
         capabilityId,
-        projectId,
-        actorId,
-        role,
-        peerId,
-        source,
-        ...(scopeId ? { scopeId } : {}),
-        ...(sessionId ? { sessionId } : {}),
         expiresAt,
         capabilityToken,
       };
@@ -530,25 +800,13 @@ export class BrowserRuntime {
   }
 
   public async acquireLease(
-    optionsArg: IAcquireBrowserRuntimeLeaseOptions,
+    optionsArg: TAcquireBrowserRuntimeLeaseOptions,
   ): Promise<BrowserRuntimeLease> {
     this.requireRunning();
     if (!optionsArg || typeof optionsArg !== 'object') {
       throw new BrowserRuntimeError('INVALID_INPUT');
     }
-    const peerId = validateBoundedString(optionsArg.peerId, 'peerId', 1, peerIdMaximum);
-    const expectedRole = optionsArg.expectedRole === undefined
-      ? undefined
-      : this.validateRole(optionsArg.expectedRole);
-    const expectedSource = optionsArg.expectedSource === undefined
-      ? undefined
-      : this.validateSource(optionsArg.expectedSource);
-    const scopeId = optionsArg.scopeId === undefined
-      ? undefined
-      : validateBoundedString(optionsArg.scopeId, 'scopeId', 1, 128);
-    const sessionId = optionsArg.sessionId === undefined
-      ? undefined
-      : validateBoundedString(optionsArg.sessionId, 'sessionId', 1, 128);
+    const expected = this.validateExpectedCapabilityBinding(optionsArg);
     this.throwIfAcquisitionAborted(optionsArg.signal);
     const capabilityToken = validateBoundedString(
       optionsArg.capabilityToken,
@@ -559,13 +817,10 @@ export class BrowserRuntime {
     const digest = digestToken(capabilityToken);
     const capability = this.resolveCapability(
       digest,
-      peerId,
-      expectedRole,
-      expectedSource,
-      scopeId,
-      sessionId,
+      expected,
     );
-    const slot = this.getOrCreateSlot(capability.projectId);
+    const slot = this.getRegisteredSlot(capability.projectId, capability.browserResourceId);
+    this.assertCapabilityStillAttached(capability, slot);
     return capability.role === 'agent'
       ? this.acquireAgentLease(slot, capability, digest, optionsArg)
       : this.acquireHumanLease(slot, capability, digest, optionsArg);
@@ -573,14 +828,16 @@ export class BrowserRuntime {
 
   public authorizeCapability(
     capabilityTokenArg: string,
-    peerIdArg: string,
-    role: TBrowserActorRole,
-    source: TBrowserCapabilitySource,
-  ): IBrowserCapabilityDescriptor {
+    expectedArg: TBrowserCapabilityAuthorizationRequest,
+  ): TBrowserCapabilityDescriptor {
     this.requireRunning();
     const token = validateBoundedString(capabilityTokenArg, 'capabilityToken', 16, 512);
-    const peerId = validateBoundedString(peerIdArg, 'peerId', 1, peerIdMaximum);
-    const record = this.resolveCapability(digestToken(token), peerId, role, source);
+    const expected = this.validateExpectedCapabilityBinding(expectedArg);
+    const record = this.resolveCapability(digestToken(token), expected);
+    this.assertCapabilityStillAttached(
+      record,
+      this.getRegisteredSlot(record.projectId, record.browserResourceId),
+    );
     return this.describeCapability(record);
   }
 
@@ -596,8 +853,22 @@ export class BrowserRuntime {
     await this.revokeCapabilityRecord(capability);
   }
 
+  /** @internal */
+  public async revokeFramedCapability(capabilityIdArg: string): Promise<void> {
+    const capabilityId = validateBoundedString(capabilityIdArg, 'capabilityId', 1, 128);
+    const capability = this.capabilitiesById.get(capabilityId);
+    if (!capability) return;
+    if (capability.source !== 'flex') throw new BrowserRuntimeError('CAPABILITY_INVALID');
+    await this.revokeCapabilityRecord(capability, false);
+  }
+
+  /** @internal */
+  public async beforeFramedPeerLeasePublication(): Promise<void> {
+    await this.options.beforeFramedPeerLeasePublication?.();
+  }
+
   public async disconnectPeer(peerIdArg: string): Promise<void> {
-    const peerId = validateBoundedString(peerIdArg, 'peerId', 1, peerIdMaximum);
+    const peerId = this.validateIdentifier(peerIdArg, 'peerId');
     const matching = [...this.capabilitiesById.values()].filter((record) => (
       record.peerId === peerId && record.state === 'active'
     ));
@@ -610,27 +881,29 @@ export class BrowserRuntime {
     if (errors.length > 0) throw new AggregateError(errors, 'Peer cleanup is incomplete');
   }
 
-  public async retireProject(projectIdArg: string): Promise<void> {
-    const projectId = validateBoundedString(projectIdArg, 'projectId', 1, projectIdMaximum);
-    const capabilities = [...this.capabilitiesById.values()].filter((record) => (
-      record.projectId === projectId
-    ));
-    const results = await Promise.allSettled(
-      capabilities.map((record) => this.revokeCapabilityRecord(record)),
-    );
-    const errors = results
-      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
-      .map((result) => result.reason);
-    if (errors.length > 0) throw new AggregateError(errors, 'Project capability cleanup is incomplete');
-    await this.retireSlot(projectId, true);
-  }
-
   public attachTrustedFramedPeer(
     options: IAttachTrustedFramedPeerOptions,
   ): BrowserRuntimeFramedServerPeer {
     this.requireRunning();
-    const peerId = validateBoundedString(options.peerId, 'peerId', 1, peerIdMaximum);
-    if ([...this.framedPeers].some((peer) => peer.peerId === peerId)) {
+    const trustedBinding = this.validateExpectedCapabilityBinding(options);
+    if (trustedBinding.source !== 'flex') throw new BrowserRuntimeError('INVALID_INPUT');
+    const slot = this.getRegisteredSlot(
+      trustedBinding.projectId,
+      trustedBinding.browserResourceId,
+    );
+    this.assertCapabilityBinding(slot, trustedBinding);
+    this.assertSlotAvailable(slot);
+    if (
+      slot.lifecycleOperationCount > 0
+      || slot.terminatePromise
+      || slot.retirePromise
+      || slot.attachmentOperations.size > 0
+    ) throw new BrowserRuntimeError('BUSY');
+    const peerId = trustedBinding.peerId;
+    const channelId = trustedBinding.channelId;
+    if ([...this.framedPeers].some((peer) => (
+      peer.peerId === peerId && peer.channelId === channelId
+    ))) {
       throw new BrowserRuntimeError('BUSY');
     }
     const peer = new BrowserRuntimeFramedServerPeer(this, options, () => {
@@ -649,7 +922,7 @@ export class BrowserRuntime {
   public getLeaseState(lease: ILeaseRecord): IBrowserRuntimeState {
     this.requireValidLease(lease);
     const session = lease.slot.session!;
-    return this.projectState(session.getState());
+    return this.resourceState(session.getState());
   }
 
   /** @internal */
@@ -673,11 +946,11 @@ export class BrowserRuntime {
   ): Promise<IBrowserRuntimeState> {
     this.requireHuman(lease);
     return this.runOperation(lease, 'createTab', operationOptions, async (signal, session) => {
-      if (session.getState().tabs.length >= this.options.maxTabsPerProject) {
+      if (session.getState().tabs.length >= this.options.maxTabsPerResource) {
         throw new BrowserRuntimeError('QUOTA_EXCEEDED');
       }
       await session.createTab(options, { signal });
-      return this.projectState(session.getState());
+      return this.resourceState(session.getState());
     });
   }
 
@@ -691,7 +964,7 @@ export class BrowserRuntime {
     const tabId = validateBoundedString(tabIdArg, 'tabId', 1, 128);
     return this.runOperation(lease, 'activateTab', operationOptions, async (signal, session) => {
       await session.activateTab(tabId, { signal });
-      return this.projectState(session.getState());
+      return this.resourceState(session.getState());
     });
   }
 
@@ -705,7 +978,7 @@ export class BrowserRuntime {
     const tabId = validateBoundedString(tabIdArg, 'tabId', 1, 128);
     return this.runOperation(lease, 'closeTab', operationOptions, async (signal, session) => {
       await session.closeTab(tabId, { signal });
-      return this.projectState(session.getState());
+      return this.resourceState(session.getState());
     });
   }
 
@@ -719,7 +992,7 @@ export class BrowserRuntime {
     this.requireHuman(lease);
     return this.runOperation(lease, action, operationOptions, async (signal, session) => {
       await session[action](options, { signal });
-      return this.projectState(session.getState());
+      return this.resourceState(session.getState());
     });
   }
 
@@ -790,7 +1063,7 @@ export class BrowserRuntime {
       slot.frameSubscription = subscription;
       this.pushToSubscription(subscription, {
         type: 'state',
-        state: this.projectState(slot.session!.getState()),
+        state: this.resourceState(slot.session!.getState()),
       });
     } finally {
       release();
@@ -832,20 +1105,14 @@ export class BrowserRuntime {
     clearTimeout(subscription.outstanding.timer);
     subscription.outstanding = undefined;
     const session = slot.session!;
+    const incarnationGeneration = slot.incarnationGeneration;
     const operation = session.acknowledgeFrame(acknowledgement);
     const result = await waitBounded(operation, this.options.frameAcknowledgementTimeoutMs)
       .catch(() => ({ settled: true as const, value: { accepted: false } }));
     if (!result.settled || !result.value.accepted) {
       operation.catch(() => undefined);
-      const errors: unknown[] = [];
-      await this.revokeCapabilityRecord(lease.capability).catch((error) => errors.push(error));
-      if (slot.session === session) {
-        await this.terminateSlotSession(slot).catch((error) => errors.push(error));
-      }
-      if (errors.length === 1) throw errors[0];
-      if (errors.length > 1) {
-        throw new AggregateError(errors, 'Frame acknowledgement cleanup is incomplete');
-      }
+      await this.options.beforeFrameFailureTermination?.();
+      await this.handleFrameFailure(slot, session, incarnationGeneration, lease);
       return false;
     }
     return true;
@@ -858,14 +1125,22 @@ export class BrowserRuntime {
   ): Promise<Uint8Array> {
     this.requireHuman(lease);
     this.requireValidLease(lease);
-    return this.artifactStore.read(lease.capability.projectId, artifactId);
+    return this.artifactStore.read(
+      lease.capability.projectId,
+      lease.capability.browserResourceId,
+      artifactId,
+    );
   }
 
   /** @internal */
   public async deleteLeaseArtifact(lease: ILeaseRecord, artifactId: string): Promise<void> {
     this.requireHuman(lease);
     this.requireValidLease(lease);
-    await this.artifactStore.delete(lease.capability.projectId, artifactId);
+    await this.artifactStore.delete(
+      lease.capability.projectId,
+      lease.capability.browserResourceId,
+      artifactId,
+    );
   }
 
   /** @internal */
@@ -924,7 +1199,9 @@ export class BrowserRuntime {
       [...revocationRecords].map((record) => this.revokeCapabilityRecord(record)),
     );
     const retirementResults = await Promise.allSettled(
-      [...this.slots.keys()].map((projectId) => this.retireSlot(projectId, true)),
+      [...this.slots.values()].map((slot) => this.enqueueResourceLifecycle(slot, async () => {
+        await this.terminateRegisteredResourceInternal(slot, true);
+      })),
     );
     while (this.cleanupOperations.size > 0) {
       await Promise.allSettled([...this.cleanupOperations]);
@@ -945,6 +1222,9 @@ export class BrowserRuntime {
       this.lockHandle = undefined;
       this.lockHandleClosed = false;
     }
+    this.slots.clear();
+    this.retiredResourceIds.fill(0);
+    this.retiredResourceKeys.fill(0);
     this.startPromise = undefined;
   }
 
@@ -952,55 +1232,29 @@ export class BrowserRuntime {
     if (this.lifecycleState !== 'running') throw new BrowserRuntimeError('NOT_RUNNING');
   }
 
-  private getOrCreateSlot(projectId: string): IProjectSlot {
-    let slot = this.slots.get(projectId);
-    if (slot) return slot;
-    if (this.slots.size >= this.options.maxProjectSlots) {
-      throw new BrowserRuntimeError('QUOTA_EXCEEDED');
-    }
-    slot = {
-      projectId,
-      mutex: new TransitionMutex(),
-      generation: 0,
-      permanentlyFenced: false,
-    };
-    this.slots.set(projectId, slot);
-    return slot;
-  }
-
   private async acquireAgentLease(
-    slot: IProjectSlot,
-    capability: ICapabilityRecord,
+    slot: IResourceSlot,
+    capability: TCapabilityRecord,
     digest: plugins.Buffer,
-    acquisition: IAcquireBrowserRuntimeLeaseOptions,
+    acquisition: TAcquireBrowserRuntimeLeaseOptions,
   ): Promise<BrowserRuntimeLease> {
     const release = slot.mutex.tryAcquire();
     if (!release) throw new BrowserRuntimeError('BUSY');
     try {
       this.assertSlotAvailable(slot);
-      this.resolveCapability(
-        digest,
-        capability.peerId,
-        acquisition.expectedRole ?? 'agent',
-        acquisition.expectedSource,
-        acquisition.scopeId,
-        acquisition.sessionId,
-      );
+      this.resolveCapability(digest, this.validateExpectedCapabilityBinding(acquisition));
+      this.assertCapabilityStillAttached(capability, slot);
       if (slot.lease || slot.operation) throw new BrowserRuntimeError('BUSY');
       await this.ensureSession(slot, acquisition.signal);
+      await this.options.beforeLeasePublication?.();
       this.throwIfAcquisitionAborted(acquisition.signal);
-      this.resolveCapability(
-        digest,
-        capability.peerId,
-        acquisition.expectedRole ?? 'agent',
-        acquisition.expectedSource,
-        acquisition.scopeId,
-        acquisition.sessionId,
-      );
+      this.assertSlotAvailable(slot);
+      this.resolveCapability(digest, this.validateExpectedCapabilityBinding(acquisition));
+      this.assertCapabilityStillAttached(capability, slot);
       const lease = this.createLeaseRecord(slot, capability, digest);
       return new BrowserRuntimeLease(this, lease);
     } catch (error) {
-      if (slot.session && !slot.lease) this.scheduleIdleRetirement(slot);
+      if (slot.session && !slot.lease) this.scheduleIdleTermination(slot);
       throw error;
     } finally {
       release();
@@ -1008,27 +1262,29 @@ export class BrowserRuntime {
   }
 
   private async acquireHumanLease(
-    slot: IProjectSlot,
-    capability: ICapabilityRecord,
+    slot: IResourceSlot,
+    capability: TCapabilityRecord,
     digest: plugins.Buffer,
-    acquisition: IAcquireBrowserRuntimeLeaseOptions,
+    acquisition: TAcquireBrowserRuntimeLeaseOptions,
   ): Promise<BrowserRuntimeLease> {
     const release = await slot.mutex.acquire();
     let generation = 0;
     let preemptedLease: ILeaseRecord | undefined;
     try {
       this.assertSlotAvailable(slot);
-      this.resolveCapability(digest, capability.peerId, 'human', 'human');
+      this.resolveCapability(digest, this.validateExpectedCapabilityBinding(acquisition));
+      this.assertCapabilityStillAttached(capability, slot);
       this.throwIfAcquisitionAborted(acquisition.signal);
       if (slot.fencingGeneration !== undefined) throw new BrowserRuntimeError('BUSY');
       if (slot.lease?.role === 'human') throw new BrowserRuntimeError('BUSY');
-      generation = ++slot.generation;
+      generation = ++slot.arbitrationGeneration;
       slot.fencingGeneration = generation;
       preemptedLease = slot.lease;
       if (preemptedLease) {
         preemptedLease.released = true;
         preemptedLease.controller.abort(new BrowserRuntimeError('ABORTED'));
         slot.operation?.controller.abort(new BrowserRuntimeError('ABORTED'));
+        this.notifyFramedLeaseEnded(preemptedLease);
       }
     } finally {
       release();
@@ -1039,7 +1295,7 @@ export class BrowserRuntime {
       this.throwIfAcquisitionAborted(acquisition.signal);
       const finalRelease = await slot.mutex.acquire();
       try {
-        if (slot.generation !== generation || slot.fencingGeneration !== generation) {
+        if (slot.arbitrationGeneration !== generation || slot.fencingGeneration !== generation) {
           throw new BrowserRuntimeError('BUSY');
         }
         if (preemptedLease) {
@@ -1051,8 +1307,11 @@ export class BrowserRuntime {
         if (slot.permanentlyFenced) throw new BrowserRuntimeError('FENCED');
         slot.fencingGeneration = undefined;
         await this.ensureSession(slot, acquisition.signal);
+        await this.options.beforeLeasePublication?.();
         this.throwIfAcquisitionAborted(acquisition.signal);
-        this.resolveCapability(digest, capability.peerId, 'human', 'human');
+        this.assertSlotAvailable(slot);
+        this.resolveCapability(digest, this.validateExpectedCapabilityBinding(acquisition));
+        this.assertCapabilityStillAttached(capability, slot);
         const lease = this.createLeaseRecord(slot, capability, digest);
         return new BrowserRuntimeLease(this, lease);
       } finally {
@@ -1068,7 +1327,7 @@ export class BrowserRuntime {
           if (slot.lease === preemptedLease) slot.lease = undefined;
         }
         if (slot.fencingGeneration === generation) slot.fencingGeneration = undefined;
-        if (slot.session && !slot.lease) this.scheduleIdleRetirement(slot);
+        if (slot.session && !slot.lease) this.scheduleIdleTermination(slot);
       } finally {
         cleanupRelease();
       }
@@ -1077,10 +1336,12 @@ export class BrowserRuntime {
   }
 
   private createLeaseRecord(
-    slot: IProjectSlot,
-    capability: ICapabilityRecord,
+    slot: IResourceSlot,
+    capability: TCapabilityRecord,
     digest: plugins.Buffer,
   ): ILeaseRecord {
+    this.assertSlotAvailable(slot);
+    this.assertCapabilityStillAttached(capability, slot);
     if (capability.lease || slot.lease) throw new BrowserRuntimeError('BUSY');
     if (slot.idleTimer) {
       clearTimeout(slot.idleTimer);
@@ -1101,9 +1362,10 @@ export class BrowserRuntime {
     return lease;
   }
 
-  private async ensureSession(slot: IProjectSlot, signalArg?: AbortSignal): Promise<void> {
+  private async ensureSession(slot: IResourceSlot, signalArg?: AbortSignal): Promise<void> {
     if (slot.session) return;
     this.assertSlotAvailable(slot);
+    this.reserveLaunch(slot);
     const profileDirectory = plugins.path.join(this.profileRoot, randomId(24));
     let profileCreated = false;
     let proxy: BrowserEgressProxy | undefined;
@@ -1115,6 +1377,7 @@ export class BrowserRuntime {
       await plugins.fsPromises.chmod(profileDirectory, 0o700);
       proxy = new BrowserEgressProxy({
         projectId: slot.projectId,
+        browserResourceId: slot.browserResourceId,
         ...this.options.egress,
       });
       await proxy.start();
@@ -1174,7 +1437,13 @@ export class BrowserRuntime {
       };
       try {
         await runBounded(session.start({ signal: probeSignal }));
-        await runBounded(this.options.confinementProbe({ session, proxy, signal: probeSignal }));
+        await runBounded(this.options.confinementProbe({
+          projectId: slot.projectId,
+          browserResourceId: slot.browserResourceId,
+          session,
+          proxy,
+          signal: probeSignal,
+        }));
       } finally {
         clearTimeout(timeout);
       }
@@ -1183,6 +1452,7 @@ export class BrowserRuntime {
       slot.proxy = proxy;
       slot.profileDirectory = profileDirectory;
       slot.unsubscribeSession = unsubscribe;
+      slot.incarnationGeneration += 1;
     } catch (error) {
       unsubscribe?.();
       let confirmed = true;
@@ -1228,6 +1498,8 @@ export class BrowserRuntime {
       throw error instanceof BrowserRuntimeError
         ? error
         : new BrowserRuntimeError('CONFINEMENT_FAILED');
+    } finally {
+      this.releaseLaunchReservation(slot);
     }
   }
 
@@ -1248,23 +1520,28 @@ export class BrowserRuntime {
       operationOptions.onOperationStarted !== undefined
       && typeof operationOptions.onOperationStarted !== 'function'
     ) throw new BrowserRuntimeError('INVALID_INPUT');
-    operationOptions.signal?.throwIfAborted();
+    if (operationOptions.signal?.aborted) throw new BrowserRuntimeError('ABORTED');
     const slot = lease.slot;
     const release = slot.mutex.tryAcquire();
     if (!release) throw new BrowserRuntimeError('BUSY');
     let operation: IOperationRecord;
-    let executionPromise: Promise<T>;
+    let executionPromise: Promise<T> | undefined;
     let combinedSignal: AbortSignal;
     let timeout: ReturnType<typeof setTimeout>;
     let session: ILiveBrowserSessionLike;
     let generation: number;
+    let incarnationGeneration: number;
+    let externalAbort = false;
+    let onExternalAbort: (() => void) | undefined;
+    let resolvePreflight!: () => void;
     const startedAt = Date.now();
     try {
       this.requireValidLease(lease);
       this.assertSlotAvailable(slot);
       if (slot.operation) throw new BrowserRuntimeError('BUSY');
       session = slot.session!;
-      generation = slot.generation;
+      generation = slot.arbitrationGeneration;
+      incarnationGeneration = slot.incarnationGeneration;
       const timeoutMs = operationOptions.timeoutMs === undefined
         ? this.options.operationTimeoutMs
         : validateInteger(operationOptions.timeoutMs, 'timeoutMs', 100, 120_000);
@@ -1274,20 +1551,25 @@ export class BrowserRuntime {
         timeoutController.abort(new BrowserRuntimeError('TIMEOUT'));
       }, timeoutMs);
       timeout.unref();
+      const externalSignal = operationOptions.signal;
+      onExternalAbort = () => { externalAbort = true; };
+      externalSignal?.addEventListener('abort', onExternalAbort, { once: true });
+      if (externalSignal?.aborted) externalAbort = true;
       combinedSignal = AbortSignal.any([
         controller.signal,
         lease.controller.signal,
-        operationOptions.signal ?? new AbortController().signal,
+        externalSignal ?? new AbortController().signal,
         timeoutController.signal,
       ]);
-      executionPromise = Promise.resolve().then(() => execute(combinedSignal, session));
       operation = {
         operationId: randomId(18),
         lease,
         controller,
         action,
         startedAt,
-        promise: executionPromise.then(() => undefined, () => undefined),
+        session,
+        incarnationGeneration,
+        promise: new Promise<void>((resolve) => { resolvePreflight = resolve; }),
       };
       slot.operation = operation;
       try {
@@ -1299,67 +1581,173 @@ export class BrowserRuntime {
       release();
     }
 
-    let phase: 'completed' | 'failed' = 'completed';
-    let errorCode: string | undefined;
+    const operationIdentity = this.createOperationIdentity(lease, operation, action, startedAt);
+
+    let result: T | undefined;
+    let failed = false;
+    let failure: unknown;
+    let executionStarted = false;
     try {
+      await this.runBeforeOperation(operationIdentity, combinedSignal);
+      const executionRelease = await slot.mutex.acquire();
+      try {
+        combinedSignal.throwIfAborted();
+        this.requireValidLease(lease);
+        this.assertSlotAvailable(slot);
+        this.assertCapabilityStillAttached(lease.capability, slot);
+        if (
+          slot.operation !== operation
+          || slot.session !== session
+          || slot.arbitrationGeneration !== generation
+          || slot.incarnationGeneration !== incarnationGeneration
+        ) throw new BrowserRuntimeError('ABORTED');
+        executionStarted = true;
+        executionPromise = execute(combinedSignal, session);
+        operation.promise = executionPromise.then(() => undefined, () => undefined);
+      } finally {
+        executionRelease();
+      }
       let onAbort!: () => void;
       const aborted = new Promise<never>((_resolve, reject) => {
         onAbort = () => reject(combinedSignal.reason ?? new BrowserRuntimeError('ABORTED'));
         combinedSignal.addEventListener('abort', onAbort, { once: true });
       });
-      let result: T;
       try {
-        result = await Promise.race([executionPromise!, aborted]);
+        result = await Promise.race([executionPromise, aborted]);
       } finally {
         combinedSignal.removeEventListener('abort', onAbort);
       }
       if (combinedSignal.aborted) throw combinedSignal.reason;
       this.requireValidLease(lease);
-      if (slot.session !== session! || slot.generation !== generation!) {
+      this.assertCapabilityStillAttached(lease.capability, slot);
+      if (slot.session !== session! || slot.arbitrationGeneration !== generation!) {
         throw new BrowserRuntimeError('ABORTED');
       }
-      return result;
     } catch (error) {
-      phase = 'failed';
-      errorCode = error instanceof BrowserRuntimeError
-        ? error.code
-        : error instanceof Error
-          ? truncateString(error.name, 64)
-          : 'Error';
-      if (combinedSignal!.aborted) {
-        this.trackCleanup(this.enforceOperationQuiescence(operation!));
-        const reason = combinedSignal!.reason;
-        throw reason instanceof BrowserRuntimeError
-          ? reason
-          : new BrowserRuntimeError(
-              reason instanceof Error && reason.name === 'TimeoutError' ? 'TIMEOUT' : 'ABORTED',
-            );
-      }
-      throw error;
+      failed = true;
+      failure = this.normalizeOperationError(error, combinedSignal!, externalAbort);
     } finally {
       clearTimeout(timeout!);
-      executionPromise!.finally(async () => {
+      operationOptions.signal?.removeEventListener('abort', onExternalAbort!);
+      resolvePreflight();
+      const cleanupSlot = async (): Promise<void> => {
         const cleanupRelease = await slot.mutex.acquire();
         try {
-          if (slot.operation === operation!) slot.operation = undefined;
+          if (slot.operation === operation) slot.operation = undefined;
         } finally {
           cleanupRelease();
         }
-      }).catch(() => undefined);
-      await this.emitAudit({
-        operationId: operation!.operationId,
-        capabilityId: lease.capability.capabilityId,
-        projectId: lease.capability.projectId,
-        actorId: lease.capability.actorId,
-        role: lease.role,
-        source: lease.capability.source,
-        action,
-        phase,
-        startedAt,
+      };
+      if (executionStarted) {
+        if (combinedSignal!.aborted) {
+          await this.enforceOperationQuiescence(operation).catch(() => undefined);
+        }
+        if (slot.operation === operation) {
+          const settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
+          if (settled.settled) await cleanupSlot();
+        }
+      } else {
+        await cleanupSlot();
+      }
+      const errorCode = failed ? this.operationErrorCode(failure) : undefined;
+      await this.emitAudit(Object.freeze({
+        ...operationIdentity,
+        phase: failed ? 'failed' : 'completed',
         finishedAt: Date.now(),
         ...(errorCode ? { errorCode } : {}),
-      });
+      }));
+    }
+    if (failed) throw failure;
+    return result as T;
+  }
+
+  private normalizeOperationError(
+    errorArg: unknown,
+    signalArg: AbortSignal,
+    externalAbortArg: boolean,
+  ): unknown {
+    if (signalArg.aborted) {
+      if (externalAbortArg) return new BrowserRuntimeError('ABORTED');
+      const reason = signalArg.reason;
+      if (reason instanceof BrowserRuntimeError) return reason;
+      return new BrowserRuntimeError(
+        reason instanceof Error && reason.name === 'TimeoutError' ? 'TIMEOUT' : 'ABORTED',
+      );
     }
+    if (errorArg instanceof BrowserRuntimeError) return errorArg;
+    if (errorArg instanceof Error && errorArg.name === 'TimeoutError') {
+      return new BrowserRuntimeError('TIMEOUT');
+    }
+    if (errorArg instanceof Error && errorArg.name === 'AbortError') {
+      return new BrowserRuntimeError('ABORTED');
+    }
+    return errorArg;
+  }
+
+  private operationErrorCode(errorArg: unknown): string {
+    return errorArg instanceof BrowserRuntimeError
+      ? errorArg.code
+      : errorArg instanceof Error
+        ? truncateString(errorArg.name, 64)
+        : 'Error';
+  }
+
+  private async runBeforeOperation(
+    operationArg: TBrowserRuntimeOperationIdentity,
+    signalArg: AbortSignal,
+  ): Promise<void> {
+    if (!this.options.beforeOperation) return;
+    signalArg.throwIfAborted();
+    const controller = new AbortController();
+    const signal = AbortSignal.any([signalArg, controller.signal]);
+    const hook = Promise.resolve().then(() => this.options.beforeOperation!(operationArg, signal));
+    void hook.catch(() => undefined);
+    let onAbort!: () => void;
+    const aborted = new Promise<never>((_resolve, reject) => {
+      onAbort = () => reject(signal.reason ?? new BrowserRuntimeError('ABORTED'));
+      signal.addEventListener('abort', onAbort, { once: true });
+    });
+    let result: Awaited<ReturnType<typeof waitBounded<void>>>;
+    try {
+      try {
+        result = await waitBounded(
+          Promise.race([hook, aborted]),
+          this.options.beforeOperationTimeoutMs,
+        );
+      } catch {
+        if (signalArg.aborted) throw signalArg.reason;
+        controller.abort(new BrowserRuntimeError('AUTHORIZATION_DENIED'));
+        throw new BrowserRuntimeError('AUTHORIZATION_DENIED');
+      }
+    } finally {
+      signal.removeEventListener('abort', onAbort);
+    }
+    if (!result.settled) {
+      controller.abort(new BrowserRuntimeError('TIMEOUT'));
+      throw new BrowserRuntimeError('TIMEOUT');
+    }
+    signalArg.throwIfAborted();
+  }
+
+  private createOperationIdentity(
+    leaseArg: ILeaseRecord,
+    operationArg: IOperationRecord,
+    actionArg: string,
+    startedAtArg: number,
+  ): TBrowserRuntimeOperationIdentity {
+    const identity = this.describeCapabilityIdentity(leaseArg.capability);
+    const sessionId = identity.role === 'agent'
+      ? Object.freeze({ ...identity.sessionId })
+      : undefined;
+    return Object.freeze({
+      ...identity,
+      ...(sessionId ? { sessionId } : {}),
+      operationId: operationArg.operationId,
+      capabilityId: leaseArg.capability.capabilityId,
+      leaseId: leaseArg.leaseId,
+      action: actionArg,
+      startedAt: startedAtArg,
+    }) as TBrowserRuntimeOperationIdentity;
   }
 
   private async executeAgentActionInternal(
@@ -1376,7 +1764,7 @@ export class BrowserRuntime {
       }, { signal });
       return {
         action: 'navigate',
-        state: this.projectState(session.getState()),
+        state: this.resourceState(session.getState()),
       } satisfies IBrowserActionStateResult;
     }
     if (action.action === 'snapshot') {
@@ -1391,7 +1779,7 @@ export class BrowserRuntime {
         title: truncateString(observation.title, 2048),
         text: truncateString(observation.text, 50_000),
         truncated: observation.truncated,
-        state: this.projectState(observation.state),
+        state: this.resourceState(observation.state),
       } satisfies IBrowserObservationResult;
     }
     if (action.action === 'screenshot') {
@@ -1406,6 +1794,7 @@ export class BrowserRuntime {
         if (lease.slot.session !== session) throw new BrowserRuntimeError('ABORTED');
         const artifact = await this.artifactStore.store(
           lease.capability.projectId,
+          lease.capability.browserResourceId,
           snapshot.mimeType,
           snapshot.data,
         );
@@ -1438,7 +1827,7 @@ export class BrowserRuntime {
     }
     return {
       action: action.action,
-      state: this.projectState(session.getState()),
+      state: this.resourceState(session.getState()),
     } satisfies IBrowserActionStateResult;
   }
 
@@ -1456,7 +1845,7 @@ export class BrowserRuntime {
     };
   }
 
-  private projectState(state: plugins.smartpuppeteer.ILiveBrowserState): IBrowserRuntimeState {
+  private resourceState(state: plugins.smartpuppeteer.ILiveBrowserState): IBrowserRuntimeState {
     return {
       status: state.status,
       activeTabId: state.activeTabId ? truncateString(state.activeTabId, 128) : null,
@@ -1491,7 +1880,7 @@ export class BrowserRuntime {
   }
 
   private handleSessionEvent(
-    slot: IProjectSlot,
+    slot: IResourceSlot,
     session: ILiveBrowserSessionLike,
     event: plugins.smartpuppeteer.TLiveBrowserEvent,
   ): void {
@@ -1530,19 +1919,27 @@ export class BrowserRuntime {
         return;
       }
       if (event.frame.data.byteLength > this.options.maxFrameBytes) {
-        this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, acknowledgement));
+        this.trackCleanup(this.acknowledgeFrameInBackground(
+          slot,
+          session,
+          acknowledgement,
+          true,
+        ));
         this.pushToSubscription(subscription, {
           type: 'error',
           error: { code: 'FRAME_TOO_LARGE', fatal: true, tabId: event.frame.tabId },
         });
-        this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
         return;
       }
       const timer = setTimeout(() => {
         if (subscription.outstanding?.acknowledgement.sequence !== acknowledgement.sequence) return;
         subscription.outstanding = undefined;
-        this.trackCleanup(this.acknowledgeFrameInBackground(slot, session, acknowledgement));
-        this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
+        this.trackCleanup(this.acknowledgeFrameInBackground(
+          slot,
+          session,
+          acknowledgement,
+          true,
+        ));
       }, this.options.frameAcknowledgementTimeoutMs);
       timer.unref();
       subscription.outstanding = { acknowledgement, timer };
@@ -1554,7 +1951,7 @@ export class BrowserRuntime {
     }
     if (!subscription || subscription.closed) return;
     if (event.type === 'state') {
-      this.pushToSubscription(subscription, { type: 'state', state: this.projectState(event.state) });
+      this.pushToSubscription(subscription, { type: 'state', state: this.resourceState(event.state) });
     } else {
       this.pushToSubscription(subscription, {
         type: 'error',
@@ -1575,17 +1972,34 @@ export class BrowserRuntime {
       this.requireValidLease(subscription.lease);
       subscription.listener(event);
     } catch {
+      const slot = subscription.lease.slot;
+      const session = slot.session;
+      const incarnationGeneration = slot.incarnationGeneration;
       if (event.type === 'frame' && subscription.outstanding) {
         const outstanding = subscription.outstanding;
         clearTimeout(outstanding.timer);
         subscription.outstanding = undefined;
         this.trackCleanup(this.acknowledgeFrameInBackground(
-          subscription.lease.slot,
-          subscription.lease.slot.session!,
+          slot,
+          session!,
           outstanding.acknowledgement,
+          true,
         ));
+        return;
+      }
+      if (!session) {
+        this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
+        return;
       }
-      this.trackCleanup(this.revokeCapabilityRecord(subscription.lease.capability));
+      this.trackCleanup((async () => {
+        await this.options.beforeFrameFailureTermination?.();
+        await this.handleFrameFailure(
+          slot,
+          session,
+          incarnationGeneration,
+          subscription.lease,
+        );
+      })());
     }
   }
 
@@ -1600,42 +2014,130 @@ export class BrowserRuntime {
       subscription.outstanding = undefined;
       const session = slot.session;
       if (session) {
+        const incarnationGeneration = slot.incarnationGeneration;
         const operation = session.acknowledgeFrame(acknowledgement);
         const result = await waitBounded(operation, this.options.frameAcknowledgementTimeoutMs)
           .catch(() => ({ settled: true as const, value: { accepted: false } }));
         if ((!result.settled || !result.value.accepted) && slot.session === session) {
           operation.catch(() => undefined);
-          await this.terminateSlotSession(slot);
+          await this.options.beforeFrameFailureTermination?.();
+          await this.handleFrameFailure(
+            slot,
+            session,
+            incarnationGeneration,
+            subscription.lease,
+          );
         }
       }
     }
   }
 
   private async acknowledgeFrameInBackground(
-    slot: IProjectSlot,
+    slot: IResourceSlot,
     session: ILiveBrowserSessionLike,
     acknowledgement: plugins.smartpuppeteer.ILiveBrowserFrameAcknowledgementRequest,
+    failLease = false,
   ): Promise<void> {
+    const failedLease = slot.session === session ? slot.lease : undefined;
+    const incarnationGeneration = slot.incarnationGeneration;
     const operation = session.acknowledgeFrame(acknowledgement);
     const result = await waitBounded(operation, this.options.frameAcknowledgementTimeoutMs)
       .catch(() => ({ settled: true as const, value: { accepted: false } }));
-    if (result.settled && result.value.accepted) return;
+    if (result.settled && result.value.accepted && !failLease) return;
     operation.catch(() => undefined);
-    if (slot.session !== session) return;
-    if (slot.lease) await this.revokeCapabilityRecord(slot.lease.capability);
-    else await this.retireSlot(slot.projectId, true);
+    await this.options.beforeFrameFailureTermination?.();
+    await this.handleFrameFailure(slot, session, incarnationGeneration, failedLease);
+  }
+
+  private async handleFrameFailure(
+    slot: IResourceSlot,
+    session: ILiveBrowserSessionLike,
+    incarnationGeneration: number,
+    lease?: ILeaseRecord,
+  ): Promise<void> {
+    let transitionGeneration = 0;
+    let ownsTransitionFence = false;
+    const release = await slot.mutex.acquire();
+    try {
+      if (lease) this.invalidateCapabilityRecord(lease.capability);
+      const borrowsLeaseReleaseFence = Boolean(
+        lease?.releaseGeneration !== undefined
+        && slot.fencingGeneration === lease.releaseGeneration,
+      );
+      if (
+        slot.session !== session
+        || slot.incarnationGeneration !== incarnationGeneration
+        || (lease && slot.lease !== lease)
+        || (slot.fencingGeneration !== undefined && !borrowsLeaseReleaseFence)
+        || slot.attachmentRetryBinding
+      ) {
+        if (lease) this.trackFrameCapabilityRevocation(lease);
+        return;
+      }
+      if (borrowsLeaseReleaseFence) {
+        transitionGeneration = slot.fencingGeneration!;
+      } else {
+        transitionGeneration = ++slot.arbitrationGeneration;
+        slot.fencingGeneration = transitionGeneration;
+        ownsTransitionFence = true;
+      }
+      if (lease) {
+        lease.released = true;
+        lease.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
+      }
+      if (!lease || slot.operation?.lease === lease) {
+        slot.operation?.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
+      }
+    } finally {
+      release();
+    }
+    if (lease) this.trackFrameCapabilityRevocation(lease);
+    await this.options.afterFrameFailureFence?.();
+    if (lease) await this.closeFrameSubscriptionIfLease(lease);
+    const errors: unknown[] = [];
+    await this.quiesceSlot(slot).catch((error) => errors.push(error));
+    await this.terminateSlotSession(slot, session).catch((error) => errors.push(error));
+    const finalRelease = await slot.mutex.acquire();
+    try {
+      if (
+        slot.arbitrationGeneration === transitionGeneration
+        && slot.fencingGeneration === transitionGeneration
+        && slot.incarnationGeneration === incarnationGeneration
+        && slot.session !== session
+      ) {
+        if (ownsTransitionFence && lease && slot.lease === lease) slot.lease = undefined;
+        if (ownsTransitionFence && lease && lease.capability.lease === lease) {
+          lease.capability.lease = undefined;
+        }
+        if (!lease || slot.operation?.lease === lease) slot.operation = undefined;
+        if (ownsTransitionFence && errors.length === 0) slot.fencingGeneration = undefined;
+      }
+    } finally {
+      finalRelease();
+    }
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) {
+      throw new AggregateError(errors, 'Frame acknowledgement cleanup is incomplete');
+    }
+  }
+
+  private trackFrameCapabilityRevocation(lease: ILeaseRecord): void {
+    const operation = lease.releasePromise
+      ? lease.releasePromise.catch(() => undefined).then(() => (
+          this.revokeCapabilityRecord(lease.capability)
+        ))
+      : this.revokeCapabilityRecord(lease.capability);
+    this.trackCleanup(operation);
   }
 
   private requireValidLease(lease: ILeaseRecord): void {
     if (lease.released || lease.controller.signal.aborted) {
       throw new BrowserRuntimeError('CAPABILITY_REVOKED');
     }
-    const capability = this.resolveCapability(
-      lease.digest,
-      lease.peerId,
-      lease.role,
-      lease.capability.source,
-    );
+    const capability = this.resolveCapability(lease.digest, this.describeCapabilityIdentity(
+      lease.capability,
+    ));
+    this.assertCapabilityStillAttached(capability, lease.slot);
     if (
       capability !== lease.capability
       || capability.lease !== lease
@@ -1648,14 +2150,10 @@ export class BrowserRuntime {
 
   private resolveCapability(
     digest: plugins.Buffer,
-    peerId: string,
-    expectedRole?: TBrowserActorRole,
-    expectedSource?: TBrowserCapabilitySource,
-    expectedScopeId?: string,
-    expectedSessionId?: string,
-  ): ICapabilityRecord {
+    expected: TBrowserCapabilityAuthorizationRequest,
+  ): TCapabilityRecord {
     const record = this.capabilitiesByDigest.get(digest.toString('hex'));
-    if (!record || !digestsEqual(record.digest, digest) || record.peerId !== peerId) {
+    if (!record || !digestsEqual(record.digest, digest)) {
       throw new BrowserRuntimeError('CAPABILITY_INVALID');
     }
     if (record.expiresAt <= Date.now()) {
@@ -1664,41 +2162,28 @@ export class BrowserRuntime {
       throw new BrowserRuntimeError('CAPABILITY_EXPIRED');
     }
     if (record.state !== 'active') throw new BrowserRuntimeError('CAPABILITY_REVOKED');
-    if (
-      (expectedRole && record.role !== expectedRole)
-      || (expectedSource && record.source !== expectedSource)
-      || (expectedScopeId && record.scopeId !== expectedScopeId)
-      || (expectedSessionId && record.sessionId !== expectedSessionId)
-    ) {
+    if (!this.capabilityIdentitiesEqual(record, expected)) {
       throw new BrowserRuntimeError('CAPABILITY_INVALID');
     }
     return record;
   }
 
-  private describeCapability(record: ICapabilityRecord): IBrowserCapabilityDescriptor {
+  private describeCapability(record: TCapabilityRecord): TBrowserCapabilityDescriptor {
     return {
+      ...this.describeCapabilityIdentity(record),
       capabilityId: record.capabilityId,
-      projectId: record.projectId,
-      actorId: record.actorId,
-      role: record.role,
-      peerId: record.peerId,
-      source: record.source,
-      ...(record.scopeId ? { scopeId: record.scopeId } : {}),
-      ...(record.sessionId ? { sessionId: record.sessionId } : {}),
       expiresAt: record.expiresAt,
     };
   }
 
   private async revokeCapabilityRecord(
-    capability: ICapabilityRecord,
+    capability: TCapabilityRecord,
     invokeDisconnect = true,
   ): Promise<void> {
     if (capability.revocationComplete) return;
     if (capability.revocationPromise) return capability.revocationPromise;
     capability.revocationInvokeDisconnect ??= invokeDisconnect;
-    if (capability.state === 'active') capability.state = 'revoked';
-    clearTimeout(capability.expiryTimer);
-    this.capabilitiesByDigest.delete(capability.digest.toString('hex'));
+    this.invalidateCapabilityRecord(capability);
     const operation = (async () => {
       const errors: unknown[] = [];
       const lease = capability.lease;
@@ -1732,9 +2217,11 @@ export class BrowserRuntime {
             capability.disconnectComplete = true;
           }
         } else {
-          const framedPeer = [...this.framedPeers].find((peer) => peer.peerId === capability.peerId);
+          const framedPeer = [...this.framedPeers].find((peer) => (
+            peer.activeCapabilityId === capability.capabilityId
+          ));
           if (framedPeer) {
-            await framedPeer.close().then(
+            await framedPeer.closeFromRuntime().then(
               () => { capability.disconnectComplete = true; },
               (error) => errors.push(error),
             );
@@ -1746,17 +2233,6 @@ export class BrowserRuntime {
       if (errors.length > 0) throw new AggregateError(errors, 'Capability cleanup is incomplete');
       capability.revocationComplete = true;
       this.capabilitiesById.delete(capability.capabilityId);
-      const slot = this.slots.get(capability.projectId);
-      if (
-        slot
-        && !slot.mutex.busy
-        && !slot.session
-        && !slot.lease
-        && !slot.operation
-        && ![...this.capabilitiesById.values()].some((record) => (
-          record.projectId === capability.projectId
-        ))
-      ) this.slots.delete(capability.projectId);
     })();
     capability.revocationPromise = operation;
     try {
@@ -1770,6 +2246,12 @@ export class BrowserRuntime {
     }
   }
 
+  private invalidateCapabilityRecord(capability: TCapabilityRecord): void {
+    if (capability.state === 'active') capability.state = 'revoked';
+    clearTimeout(capability.expiryTimer);
+    this.capabilitiesByDigest.delete(capability.digest.toString('hex'));
+  }
+
   private async releaseLeaseRecord(lease: ILeaseRecord): Promise<void> {
     if (lease.releasePromise) return lease.releasePromise;
     const operation = this.releaseLeaseRecordInternal(lease);
@@ -1785,10 +2267,14 @@ export class BrowserRuntime {
     if (lease.released && lease.slot.lease !== lease) return;
     const slot = lease.slot;
     const release = await slot.mutex.acquire();
-    const generation = lease.releaseGeneration ?? ++slot.generation;
+    const existingFence = slot.fencingGeneration;
+    const generation = lease.releaseGeneration
+      ?? existingFence
+      ?? ++slot.arbitrationGeneration;
     lease.releaseGeneration = generation;
+    lease.releaseOwnsFence ??= existingFence === undefined;
     try {
-      if (slot.fencingGeneration !== undefined && slot.fencingGeneration !== generation) {
+      if (existingFence !== undefined) {
         lease.controller.abort(new BrowserRuntimeError('ABORTED'));
       } else {
         slot.fencingGeneration = generation;
@@ -1809,11 +2295,15 @@ export class BrowserRuntime {
     ) await this.terminateSlotSession(slot);
     const finalRelease = await slot.mutex.acquire();
     try {
+      if (lease.capability.state === 'active') this.notifyFramedLeaseEnded(lease);
       if (slot.lease === lease) slot.lease = undefined;
       if (lease.capability.lease === lease) lease.capability.lease = undefined;
-      if (slot.fencingGeneration === generation) slot.fencingGeneration = undefined;
+      if (lease.releaseOwnsFence && slot.fencingGeneration === generation) {
+        slot.fencingGeneration = undefined;
+      }
       lease.releaseGeneration = undefined;
-      this.scheduleIdleRetirement(slot);
+      lease.releaseOwnsFence = undefined;
+      this.scheduleIdleTermination(slot);
     } finally {
       finalRelease();
     }
@@ -1824,7 +2314,7 @@ export class BrowserRuntime {
     if (subscription?.lease === lease) await this.closeFrameSubscription(subscription);
   }
 
-  private async quiesceSlot(slot: IProjectSlot): Promise<void> {
+  private async quiesceSlot(slot: IResourceSlot): Promise<void> {
     const operation = slot.operation;
     if (!operation) return;
     operation.controller.abort(new BrowserRuntimeError('ABORTED'));
@@ -1835,13 +2325,54 @@ export class BrowserRuntime {
   }
 
   private async enforceOperationQuiescence(operation: IOperationRecord): Promise<void> {
-    const settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
-    if (settled.settled || operation.lease.released) return;
-    await this.revokeCapabilityRecord(operation.lease.capability);
+    let settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
+    if (settled.settled) return;
+    let cleanupError: unknown;
+    try {
+      if (!operation.lease.released) {
+        await this.revokeCapabilityRecord(operation.lease.capability);
+      } else if (operation.lease.releasePromise) {
+        await waitBounded(operation.lease.releasePromise, this.options.quiescenceTimeoutMs);
+      }
+    } catch (error) {
+      cleanupError = error;
+    }
+    if (operation.lease.slot.operation !== operation) {
+      if (cleanupError) throw cleanupError;
+      return;
+    }
+    settled = await waitBounded(operation.promise, this.options.quiescenceTimeoutMs);
+    if (settled.settled) {
+      if (cleanupError) throw cleanupError;
+      return;
+    }
+    const slot = operation.lease.slot;
+    const release = await slot.mutex.acquire();
+    try {
+      if (
+        slot.operation === operation
+        && (
+          slot.permanentlyFenced
+          || slot.session !== operation.session
+          || slot.incarnationGeneration !== operation.incarnationGeneration
+        )
+      ) slot.operation = undefined;
+    } finally {
+      release();
+    }
+    if (cleanupError) throw cleanupError;
   }
 
-  private async terminateSlotSession(slot: IProjectSlot): Promise<void> {
+  private async terminateSlotSession(
+    slot: IResourceSlot,
+    expectedSession?: ILiveBrowserSessionLike,
+  ): Promise<void> {
+    if (slot.idleTimer) {
+      clearTimeout(slot.idleTimer);
+      slot.idleTimer = undefined;
+    }
     const session = slot.session;
+    if (expectedSession && session !== expectedSession) return;
     if (session) {
       let termination: plugins.smartpuppeteer.ILiveBrowserTerminationResult;
       try {
@@ -1881,13 +2412,24 @@ export class BrowserRuntime {
     if (slot.proxy || slot.profileDirectory) throw new BrowserRuntimeError('FENCED');
   }
 
-  private scheduleIdleRetirement(slot: IProjectSlot): void {
+  private scheduleIdleTermination(slot: IResourceSlot): void {
+    if (slot.terminationFenceGeneration !== undefined || slot.retirementPending) return;
     if (slot.idleTimer) clearTimeout(slot.idleTimer);
-    const generation = slot.generation;
+    const arbitrationGeneration = slot.arbitrationGeneration;
+    const incarnationGeneration = slot.incarnationGeneration;
+    const scheduledSession = slot.session;
     slot.idleTimer = setTimeout(() => {
-      if (slot.generation !== generation || slot.lease) return;
-      this.trackCleanup(this.retireSlot(slot.projectId, false));
-    }, this.options.idleRetirementMs);
+      slot.idleTimer = undefined;
+      this.trackCleanup(this.enqueueResourceLifecycle(slot, async () => {
+        await this.options.beforeIdleTermination?.();
+        await this.terminateRegisteredResourceInternal(slot, false, {
+          arbitrationGeneration,
+          incarnationGeneration,
+          session: scheduledSession,
+          requireIdle: true,
+        });
+      }));
+    }, this.options.idleTerminationMs);
     slot.idleTimer.unref();
   }
 
@@ -1903,14 +2445,33 @@ export class BrowserRuntime {
     }
   }
 
-  private async retireSlot(projectId: string, force: boolean): Promise<void> {
-    const slot = this.slots.get(projectId);
-    if (!slot) return;
+  private async terminateRegisteredResourceInternal(
+    slot: IResourceSlot,
+    stopping: boolean,
+    expected?: {
+      arbitrationGeneration?: number;
+      incarnationGeneration?: number;
+      session?: ILiveBrowserSessionLike;
+      requireIdle?: boolean;
+    },
+  ): Promise<void> {
     const release = await slot.mutex.acquire();
-    const generation = ++slot.generation;
+    let generation = 0;
+    let attachmentFenceOwnsTransition = false;
     try {
-      if (!force && (slot.lease || slot.operation)) return;
-      slot.fencingGeneration = generation;
+      if (
+        (expected?.arbitrationGeneration !== undefined
+          && slot.arbitrationGeneration !== expected.arbitrationGeneration)
+        || (expected?.incarnationGeneration !== undefined
+          && slot.incarnationGeneration !== expected.incarnationGeneration)
+        || (expected?.session !== undefined && slot.session !== expected.session)
+        || (expected?.requireIdle && slot.lease)
+      ) return;
+      attachmentFenceOwnsTransition = slot.attachmentRetryBinding !== undefined;
+      if (!attachmentFenceOwnsTransition) {
+        generation = ++slot.arbitrationGeneration;
+        slot.fencingGeneration = generation;
+      }
       if (slot.idleTimer) {
         clearTimeout(slot.idleTimer);
         slot.idleTimer = undefined;
@@ -1918,18 +2479,27 @@ export class BrowserRuntime {
       if (slot.lease) {
         slot.lease.released = true;
         slot.lease.controller.abort(new BrowserRuntimeError('ABORTED'));
+        if (!stopping && !attachmentFenceOwnsTransition) {
+          this.notifyFramedLeaseEnded(slot.lease);
+        }
       }
       slot.operation?.controller.abort(new BrowserRuntimeError('ABORTED'));
     } finally {
       release();
     }
+    if (attachmentFenceOwnsTransition) {
+      await this.quiesceSlot(slot);
+      if (slot.lease) await this.closeFrameSubscriptionIfLease(slot.lease);
+      await this.terminateSlotSession(slot, expected?.session);
+      return;
+    }
+    if (generation === 0) return;
     await this.quiesceSlot(slot);
     if (slot.lease) await this.closeFrameSubscriptionIfLease(slot.lease);
-    await this.terminateSlotSession(slot);
-    await this.artifactStore.purgeProject(projectId);
+    await this.terminateSlotSession(slot, expected?.session);
     const finalRelease = await slot.mutex.acquire();
     try {
-      if (slot.generation !== generation || slot.fencingGeneration !== generation) {
+      if (slot.arbitrationGeneration !== generation || slot.fencingGeneration !== generation) {
         throw new BrowserRuntimeError('BUSY');
       }
       const lease = slot.lease;
@@ -1939,14 +2509,48 @@ export class BrowserRuntime {
       slot.lease = undefined;
       slot.operation = undefined;
       slot.fencingGeneration = undefined;
-      this.slots.delete(projectId);
     } finally {
       finalRelease();
     }
   }
 
-  private assertSlotAvailable(slot: IProjectSlot): void {
+  private async retireRegisteredResourceInternal(slot: IResourceSlot): Promise<void> {
+    const key = this.resourceKey(slot.projectId, slot.browserResourceId);
+    if (this.slots.get(key) !== slot) return;
+    const peerResults = await Promise.allSettled(
+      this.framedPeersForResource(slot).map((peer) => peer.close()),
+    );
+    const capabilities = this.capabilitiesForResource(slot);
+    const capabilityResults = await Promise.allSettled(
+      capabilities.map((record) => this.revokeCapabilityRecord(record)),
+    );
+    const errors = [...peerResults, ...capabilityResults]
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason);
+    await this.terminateRegisteredResourceInternal(slot, true).catch((error) => errors.push(error));
+    if (errors.length === 0) {
+      await this.artifactStore.purgeResource(slot.projectId, slot.browserResourceId)
+        .catch((error) => errors.push(error));
+    }
+    if (errors.length > 0) {
+      slot.permanentlyFenced = true;
+      throw new AggregateError(errors, 'Resource retirement is incomplete');
+    }
+    this.slots.delete(key);
+  }
+
+  private framedPeersForResource(slot: IResourceSlot): BrowserRuntimeFramedServerPeer[] {
+    return [...this.framedPeers].filter((peer) => (
+        peer.projectId === slot.projectId
+        && peer.browserResourceId === slot.browserResourceId
+    ));
+  }
+
+  private assertSlotAvailable(slot: IResourceSlot): void {
+    if (slot.retirementPending) throw new BrowserRuntimeError('RESOURCE_RETIRED');
     if (slot.permanentlyFenced) throw new BrowserRuntimeError('FENCED');
+    if (slot.terminationFenceGeneration !== undefined) throw new BrowserRuntimeError('BUSY');
+    if (slot.attachmentFenceCount > 0) throw new BrowserRuntimeError('BUSY');
     if (slot.fencingGeneration !== undefined) throw new BrowserRuntimeError('BUSY');
   }
 
@@ -1958,6 +2562,416 @@ export class BrowserRuntime {
     if (lease.role !== 'human') throw new BrowserRuntimeError('CAPABILITY_INVALID');
   }
 
+  private enqueueResourceLifecycle<T>(
+    slot: IResourceSlot,
+    operation: () => Promise<T>,
+  ): Promise<T> {
+    slot.lifecycleOperationCount += 1;
+    const queued = slot.lifecycleTail.then(operation, operation);
+    const result = queued.finally(() => {
+      slot.lifecycleOperationCount = Math.max(0, slot.lifecycleOperationCount - 1);
+    });
+    slot.lifecycleTail = result.then(() => undefined, () => undefined);
+    return result;
+  }
+
+  private notifyFramedLeaseEnded(lease: ILeaseRecord): void {
+    if (lease.capability.source !== 'flex') return;
+    const peer = [...this.framedPeers].find((candidate) => (
+      candidate.activeCapabilityId === lease.capability.capabilityId
+      && candidate.channelId === lease.capability.channelId
+    ));
+    peer?.releaseLeaseFromRuntime(lease.capability.capabilityId, lease.leaseId);
+  }
+
+  private async applyAttachmentBindingInternal(
+    slot: IResourceSlot,
+    binding: IBrowserAttachmentBinding,
+  ): Promise<IBrowserResourceRegistration> {
+    if (slot.retirementPending) throw new BrowserRuntimeError('RESOURCE_RETIRED');
+    const current = slot.attachmentBinding;
+    if (binding.attachmentRevision < current.attachmentRevision) {
+      throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+    }
+    if (
+      binding.attachmentRevision === current.attachmentRevision
+      && !slot.attachmentRetryBinding
+    ) {
+      if (!this.bindingsEqual(binding, current)) {
+        throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+      }
+      return this.describeResource(slot);
+    }
+    if (
+      slot.attachmentRetryBinding
+      && !this.bindingsEqual(binding, slot.attachmentRetryBinding)
+    ) throw new BrowserRuntimeError('BUSY');
+    const release = await slot.mutex.acquire();
+    let fenceGeneration = 0;
+    try {
+      fenceGeneration = ++slot.arbitrationGeneration;
+      slot.fencingGeneration = fenceGeneration;
+      slot.attachmentBinding = binding;
+      slot.attachmentRetryBinding = binding;
+      slot.lease?.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
+      slot.operation?.controller.abort(new BrowserRuntimeError('CAPABILITY_REVOKED'));
+    } finally {
+      release();
+    }
+    const peerResults = await Promise.allSettled(
+      this.framedPeersForResource(slot).map((peer) => peer.close()),
+    );
+    const capabilities = this.capabilitiesForResource(slot);
+    const capabilityResults = await Promise.allSettled(
+      capabilities.map((record) => this.revokeCapabilityRecord(record)),
+    );
+    const errors = [...peerResults, ...capabilityResults]
+      .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
+      .map((result) => result.reason);
+    await this.quiesceSlot(slot).catch((error) => errors.push(error));
+    const finalRelease = await slot.mutex.acquire();
+    try {
+      if (slot.fencingGeneration === fenceGeneration && errors.length === 0) {
+        slot.fencingGeneration = undefined;
+        slot.attachmentRetryBinding = undefined;
+      }
+    } finally {
+      finalRelease();
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, 'Attachment fencing is incomplete');
+    }
+    return this.describeResource(slot);
+  }
+
+  private attachmentBindingKey(binding: IBrowserAttachmentBinding): string {
+    const session = binding.sessionId
+      ? `${binding.sessionId.harnessId}:${binding.sessionId.nativeId}`
+      : 'detached';
+    return `${binding.attachmentRevision}:${binding.attachmentAuthorityId}:${session}`;
+  }
+
+  private tombstoneIndex(value: string, seed: number): number {
+    const digest = plugins.crypto
+      .createHash('sha256')
+      .update(String(seed), 'utf8')
+      .update('\0', 'utf8')
+      .update(value, 'utf8')
+      .digest();
+    return digest.readUInt32BE(0) % (this.retiredResourceIds.length * 8);
+  }
+
+  private addRetiredTombstone(tombstones: Uint8Array, value: string): void {
+    for (let seed = 0; seed < 4; seed += 1) {
+      const index = this.tombstoneIndex(value, seed);
+      tombstones[index >>> 3] |= 1 << (index & 7);
+    }
+  }
+
+  private hasRetiredTombstone(tombstones: Uint8Array, value: string): boolean {
+    for (let seed = 0; seed < 4; seed += 1) {
+      const index = this.tombstoneIndex(value, seed);
+      if ((tombstones[index >>> 3]! & (1 << (index & 7))) === 0) return false;
+    }
+    return true;
+  }
+
+  private resourceKey(projectId: string, browserResourceId: string): string {
+    return `${projectId.length}:${projectId}${browserResourceId}`;
+  }
+
+  private validateIdentifier(value: unknown, name: string): string {
+    return validateBoundedString(value, name, 1, identifierMaximum);
+  }
+
+  private validateResourceId(value: unknown): string {
+    return validateBoundedString(value, 'browserResourceId', 16, identifierMaximum);
+  }
+
+  private validateQualifiedSessionId(value: unknown): TQualifiedBrowserSessionId {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    const record = value as Record<string, unknown>;
+    if (Object.keys(record).some((key) => key !== 'harnessId' && key !== 'nativeId')) {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    if (record.harnessId !== 'opencode' && record.harnessId !== 'flex') {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    return {
+      harnessId: record.harnessId,
+      nativeId: this.validateIdentifier(record.nativeId, 'sessionId.nativeId'),
+    };
+  }
+
+  private validateAttachmentBinding(value: unknown): IBrowserAttachmentBinding {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    const record = value as Record<string, unknown>;
+    if (Object.keys(record).some((key) => (
+      key !== 'attachmentAuthorityId'
+      && key !== 'attachmentRevision'
+      && key !== 'sessionId'
+    ))) throw new BrowserRuntimeError('INVALID_INPUT');
+    const attachmentRevision = validateInteger(
+      record.attachmentRevision,
+      'attachmentRevision',
+      0,
+      Number.MAX_SAFE_INTEGER,
+    );
+    const sessionId = record.sessionId === null
+      ? null
+      : this.validateQualifiedSessionId(record.sessionId);
+    if (attachmentRevision === 0 && sessionId !== null) {
+      throw new BrowserRuntimeError('INVALID_INPUT');
+    }
+    return {
+      attachmentAuthorityId: this.validateIdentifier(
+        record.attachmentAuthorityId,
+        'attachmentAuthorityId',
+      ),
+      attachmentRevision,
+      sessionId,
+    };
+  }
+
+  private bindingsEqual(
+    left: IBrowserAttachmentBinding,
+    right: IBrowserAttachmentBinding,
+  ): boolean {
+    return left.attachmentAuthorityId === right.attachmentAuthorityId
+      && left.attachmentRevision === right.attachmentRevision
+      && this.sessionsEqual(left.sessionId, right.sessionId);
+  }
+
+  private sessionsEqual(
+    left: TQualifiedBrowserSessionId | null | undefined,
+    right: TQualifiedBrowserSessionId | null | undefined,
+  ): boolean {
+    if (left == null || right == null) return left == null && right == null;
+    return left.harnessId === right.harnessId && left.nativeId === right.nativeId;
+  }
+
+  private resolveResourceRequest(
+    request: { projectId: string; browserResourceId: string },
+  ): IResourceSlot {
+    if (!request || typeof request !== 'object') throw new BrowserRuntimeError('INVALID_INPUT');
+    return this.getRegisteredSlot(request.projectId, request.browserResourceId);
+  }
+
+  private getRegisteredSlot(projectIdArg: unknown, browserResourceIdArg: unknown): IResourceSlot {
+    const projectId = this.validateIdentifier(projectIdArg, 'projectId');
+    const browserResourceId = this.validateResourceId(browserResourceIdArg);
+    const key = this.resourceKey(projectId, browserResourceId);
+    const slot = this.slots.get(key);
+    if (!slot) {
+      throw new BrowserRuntimeError(
+        this.hasRetiredTombstone(this.retiredResourceKeys, key)
+          ? 'RESOURCE_RETIRED'
+          : 'RESOURCE_NOT_FOUND',
+      );
+    }
+    return slot;
+  }
+
+  private describeResource(slot: IResourceSlot): IBrowserResourceRegistration {
+    return {
+      projectId: slot.projectId,
+      browserResourceId: slot.browserResourceId,
+      registeredAt: slot.registeredAt,
+      attachmentBinding: {
+        ...slot.attachmentBinding,
+        sessionId: slot.attachmentBinding.sessionId
+          ? { ...slot.attachmentBinding.sessionId }
+          : null,
+      },
+      incarnationStatus: slot.permanentlyFenced || slot.attachmentRetryBinding
+        ? 'fenced'
+        : slot.session
+          ? 'running'
+          : 'absent',
+      incarnationGeneration: slot.incarnationGeneration,
+      retirementPending: slot.retirementPending,
+    };
+  }
+
+  private assertCapabilityBinding(
+    slot: IResourceSlot,
+    expected: Pick<
+      TIssueBrowserCapabilityRequest,
+      'attachmentAuthorityId' | 'attachmentRevision' | 'role' | 'sessionId'
+    >,
+  ): void {
+    const binding = slot.attachmentBinding;
+    if (
+      binding.attachmentAuthorityId !== expected.attachmentAuthorityId
+      || binding.attachmentRevision !== expected.attachmentRevision
+    ) throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+    if (expected.role === 'agent') {
+      if (!binding.sessionId || !this.sessionsEqual(binding.sessionId, expected.sessionId)) {
+        throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+      }
+    } else if (expected.sessionId !== undefined) {
+      throw new BrowserRuntimeError('ATTACHMENT_CONFLICT');
+    }
+  }
+
+  private assertCapabilityStillAttached(
+    capability: TCapabilityRecord,
+    slot: IResourceSlot,
+  ): void {
+    if (
+      capability.projectId !== slot.projectId
+      || capability.browserResourceId !== slot.browserResourceId
+    ) throw new BrowserRuntimeError('CAPABILITY_INVALID');
+    try {
+      this.assertCapabilityBinding(slot, capability);
+    } catch {
+      throw new BrowserRuntimeError('CAPABILITY_REVOKED');
+    }
+  }
+
+  private validateExpectedCapabilityBinding(
+    value: TBrowserCapabilityAuthorizationRequest,
+  ): TBrowserCapabilityAuthorizationRequest {
+    if (!value || typeof value !== 'object') throw new BrowserRuntimeError('INVALID_INPUT');
+    const role = this.validateRole(value.role);
+    const source = this.validateSource(value.source);
+    const sessionId = value.sessionId === undefined
+      ? undefined
+      : this.validateQualifiedSessionId(value.sessionId);
+    const scopeId = value.scopeId === undefined
+      ? undefined
+      : this.validateIdentifier(value.scopeId, 'scopeId');
+    const channelId = value.channelId === undefined
+      ? undefined
+      : this.validateIdentifier(value.channelId, 'channelId');
+    if (
+      (role === 'agent' && !sessionId)
+      || (role === 'human' && sessionId !== undefined)
+      || (source === 'flex' && (!scopeId || !channelId || sessionId?.harnessId !== 'flex'))
+      || (source === 'mcp' && (scopeId !== undefined || channelId !== undefined
+        || sessionId?.harnessId !== 'opencode'))
+      || (source === 'human' && (scopeId !== undefined || channelId !== undefined))
+    ) throw new BrowserRuntimeError('INVALID_INPUT');
+    const base = {
+      projectId: this.validateIdentifier(value.projectId, 'projectId'),
+      browserResourceId: this.validateResourceId(value.browserResourceId),
+      attachmentAuthorityId: this.validateIdentifier(
+        value.attachmentAuthorityId,
+        'attachmentAuthorityId',
+      ),
+      attachmentRevision: validateInteger(
+        value.attachmentRevision,
+        'attachmentRevision',
+        0,
+        Number.MAX_SAFE_INTEGER,
+      ),
+      actorId: this.validateIdentifier(value.actorId, 'actorId'),
+      peerId: this.validateIdentifier(value.peerId, 'peerId'),
+    };
+    if (role === 'human' && source === 'human') {
+      return { ...base, role, source };
+    }
+    if (role === 'agent' && source === 'flex' && sessionId?.harnessId === 'flex') {
+      return { ...base, role, source, sessionId, scopeId: scopeId!, channelId: channelId! };
+    }
+    if (role === 'agent' && source === 'mcp' && sessionId?.harnessId === 'opencode') {
+      return { ...base, role, source, sessionId };
+    }
+    throw new BrowserRuntimeError('INVALID_INPUT');
+  }
+
+  private describeCapabilityIdentity(
+    capability: TBrowserCapabilityDescriptor,
+  ): TBrowserCapabilityAuthorizationRequest {
+    const base = {
+      projectId: capability.projectId,
+      browserResourceId: capability.browserResourceId,
+      attachmentAuthorityId: capability.attachmentAuthorityId,
+      attachmentRevision: capability.attachmentRevision,
+      actorId: capability.actorId,
+      peerId: capability.peerId,
+    };
+    if (capability.role === 'human' && capability.source === 'human') {
+      return { ...base, role: capability.role, source: capability.source };
+    }
+    if (
+      capability.role === 'agent'
+      && capability.source === 'flex'
+      && capability.sessionId?.harnessId === 'flex'
+    ) {
+      return {
+        ...base,
+        role: capability.role,
+        source: capability.source,
+        sessionId: capability.sessionId,
+        scopeId: capability.scopeId!,
+        channelId: capability.channelId!,
+      };
+    }
+    if (
+      capability.role === 'agent'
+      && capability.source === 'mcp'
+      && capability.sessionId?.harnessId === 'opencode'
+    ) {
+      return {
+        ...base,
+        role: capability.role,
+        source: capability.source,
+        sessionId: capability.sessionId,
+      };
+    }
+    throw new BrowserRuntimeError('CAPABILITY_INVALID');
+  }
+
+  private capabilityIdentitiesEqual(
+    left: TBrowserCapabilityAuthorizationRequest,
+    right: TBrowserCapabilityAuthorizationRequest,
+  ): boolean {
+    return left.projectId === right.projectId
+      && left.browserResourceId === right.browserResourceId
+      && left.attachmentAuthorityId === right.attachmentAuthorityId
+      && left.attachmentRevision === right.attachmentRevision
+      && left.actorId === right.actorId
+      && left.role === right.role
+      && left.peerId === right.peerId
+      && left.source === right.source
+      && left.scopeId === right.scopeId
+      && left.channelId === right.channelId
+      && this.sessionsEqual(left.sessionId, right.sessionId);
+  }
+
+  private capabilitiesForResource(slot: IResourceSlot): TCapabilityRecord[] {
+    return [...this.capabilitiesById.values()].filter((record) => (
+      record.projectId === slot.projectId
+      && record.browserResourceId === slot.browserResourceId
+    ));
+  }
+
+  private reserveLaunch(slot: IResourceSlot): void {
+    const running = [...this.slots.values()].filter((candidate) => Boolean(candidate.session)).length;
+    const runningForProject = [...this.slots.values()].filter((candidate) => (
+      candidate.projectId === slot.projectId && candidate.session
+    )).length;
+    const pendingForProject = this.pendingLaunchesByProject.get(slot.projectId) ?? 0;
+    if (
+      running + this.pendingLaunches >= this.options.maxRunningResources
+      || runningForProject + pendingForProject >= this.options.maxRunningResourcesPerProject
+    ) throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+    this.pendingLaunches += 1;
+    this.pendingLaunchesByProject.set(slot.projectId, pendingForProject + 1);
+  }
+
+  private releaseLaunchReservation(slot: IResourceSlot): void {
+    this.pendingLaunches = Math.max(0, this.pendingLaunches - 1);
+    const remaining = (this.pendingLaunchesByProject.get(slot.projectId) ?? 1) - 1;
+    if (remaining > 0) this.pendingLaunchesByProject.set(slot.projectId, remaining);
+    else this.pendingLaunchesByProject.delete(slot.projectId);
+  }
+
   private validateRole(value: unknown): TBrowserActorRole {
     if (value !== 'human' && value !== 'agent') throw new BrowserRuntimeError('INVALID_INPUT');
     return value;
@@ -1977,7 +2991,7 @@ export class BrowserRuntime {
     this.cleanupOperations.add(observed);
   }
 
-  private async emitAudit(event: IBrowserRuntimeAuditEvent): Promise<void> {
+  private async emitAudit(event: TBrowserRuntimeAuditEvent): Promise<void> {
     if (!this.options.audit) return;
     const controller = new AbortController();
     const operation = Promise.resolve().then(() => this.options.audit!(event, controller.signal));
@@ -2002,6 +3016,10 @@ export class BrowserRuntimeLease {
     return this.record.leaseId;
   }
 
+  public get capabilityId(): string {
+    return this.record.capability.capabilityId;
+  }
+
   public get role(): TBrowserActorRole {
     return this.record.role;
   }
@@ -2010,6 +3028,18 @@ export class BrowserRuntimeLease {
     return this.record.capability.projectId;
   }
 
+  public get browserResourceId(): string {
+    return this.record.capability.browserResourceId;
+  }
+
+  public get attachmentAuthorityId(): string {
+    return this.record.capability.attachmentAuthorityId;
+  }
+
+  public get attachmentRevision(): number {
+    return this.record.capability.attachmentRevision;
+  }
+
   public getState(): IBrowserRuntimeState {
     return this.runtime.getLeaseState(this.record);
   }