@@ -162,6 +162,11 @@ export function isRequestCanceledError(error: unknown): boolean {
   return error.message === REQUEST_CANCELED_MESSAGE;
 }
 
+/** The message of whatever was thrown, for diagnostics that must not themselves throw. */
+export function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export function asAppError(err: unknown, fallbackCode: AppErrorCode = 'UNKNOWN'): AppError {
   if (err instanceof AppError) return err;
   if (err instanceof Error) {
 
@@ -24,7 +24,7 @@ import { setTimeout as sleep } from 'node:timers/promises';
 import { AppError } from '@agent-device/kernel/errors';
 import type { RunHostCommand } from './dependencies.ts';
 import { CLOUD_WEBDRIVER_PROVIDERS } from './providers.ts';
-import { resolveLeaseValue, type LeaseValue } from './webdriver-utils.ts';
+import { releaseOnFailure, resolveLeaseValue, type LeaseValue } from './webdriver-utils.ts';
 
 const AWS_DEVICE_FARM_PROVIDER = CLOUD_WEBDRIVER_PROVIDERS.awsDeviceFarm;
 export const AWS_DEVICE_FARM_CAPABILITY_OVERRIDES = {
@@ -231,7 +231,7 @@ export function createAwsDeviceFarmPrepareSession(
         );
       }
     } catch (error) {
-      await stopRemoteAccessSessionAfterFailure(options.client, remoteAccess.arn, error);
+      await releaseOnFailure(error, () => options.client.stopRemoteAccessSession(remoteAccess.arn));
       throw error;
     }
     const deviceName = running.device?.name ?? options.deviceName;
@@ -327,23 +327,6 @@ function throwIfRemoteAccessSessionEnded(session: AwsDeviceFarmRemoteAccessSessi
   });
 }
 
-async function stopRemoteAccessSessionAfterFailure(
-  client: AwsDeviceFarmClient,
-  arn: string,
-  primaryError: unknown,
-): Promise<void> {
-  try {
-    await client.stopRemoteAccessSession(arn);
-  } catch (cleanupError) {
-    if (primaryError instanceof AppError) {
-      primaryError.details = {
-        ...primaryError.details,
-        cleanupError: cleanupError instanceof Error ? cleanupError.message : String(cleanupError),
-      };
-    }
-  }
-}
-
 async function runAwsJson(
   runHostCommand: RunHostCommand,
   command: string,
 
@@ -4,7 +4,7 @@ import type {
 } from '@agent-device/contracts/observability';
 import type { DeviceLease, LeaseLifecycleContext } from '@agent-device/contracts/device';
 import { deviceFieldsFromPublicPlatform, type DeviceInfo } from '@agent-device/kernel/device';
-import { AppError } from '@agent-device/kernel/errors';
+import { AppError, errorMessage } from '@agent-device/kernel/errors';
 import { unavailableCloudArtifactsResult } from './artifact-results.ts';
 import {
   createCloudWebDriverCapabilities,
@@ -14,7 +14,7 @@ import { WebDriverClient, type WebDriverSession } from './webdriver-client.ts';
 import { isWebDriverRequestTimeout } from './webdriver-transport.ts';
 import { createWebDriverInteractor } from './webdriver-interactor.ts';
 import { snapshotBackendForPlatform } from './runtime-helpers.ts';
-import { errorMessage, releaseOnFailure } from './webdriver-utils.ts';
+import { releaseOnFailure } from './webdriver-utils.ts';
 import type {
   CloudWebDriverBaseSession,
   CloudWebDriverPlatform,
 
@@ -46,7 +46,8 @@ export type WebDriverTransportOptions = {
   endpoint: string | URL;
   auth?: WebDriverAuth;
   headers?: Record<string, string>;
-  requestPolicy?: WebDriverRequestPolicy;
+  /** Session creation is the client's phase; the transport sees only per-request policy. */
+  requestPolicy?: Omit<WebDriverRequestPolicy, 'sessionCreateTimeoutMs'>;
 };
 
 type WebDriverResponse = {
@@ -61,7 +62,7 @@ type ResolvedWebDriverRequestOverrides = {
 };
 
 type ResolvedWebDriverRequestPolicy = Required<
-  Pick<WebDriverRequestPolicy, 'timeoutMs' | 'retryAttempts' | 'retryDelayMs'>
+  NonNullable<WebDriverTransportOptions['requestPolicy']>
 >;
 
 /** Focused HTTP/retry policy for one WebDriver endpoint; session semantics stay in WebDriverClient. */
 
@@ -1,12 +1,8 @@
 import type { DeviceLease } from '@agent-device/contracts/device';
-import { AppError } from '@agent-device/kernel/errors';
+import { AppError, errorMessage } from '@agent-device/kernel/errors';
 
 export type LeaseValue<T> = T | ((lease: DeviceLease) => T);
 
-export function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
 /** Best-effort release after a failure; a failed release rides along as `cleanupError`, never masks the primary. */
 export async function releaseOnFailure(
   primaryError: unknown,
 
@@ -331,6 +331,7 @@ test('a lease allocated for a requester that left is released, not registered',
         assert.ok(isRequestCanceledError(error));
         const details = (error as AppError).details ?? {};
         assert.equal(details.released, true);
+        assert.equal(details.providerReleased, true);
         assert.match(String(details.providerSessionId), /^bs-/);
         return true;
       },
@@ -376,7 +377,8 @@ test('a failed provider release after cancellation is reported as unreleased wit
       (error: unknown) => {
         assert.ok(isRequestCanceledError(error));
         const details = (error as AppError).details ?? {};
-        assert.equal(details.released, false);
+        assert.equal(details.released, true, 'the daemon lease record is gone either way');
+        assert.equal(details.providerReleased, false);
         assert.equal(details.providerSessionId, 'bs-live');
         assert.match(String(details.hint), /could NOT be confirmed released/);
         assert.match(String(details.hint), /bs-live/);
 
@@ -9,7 +9,7 @@ import type {
   CloudArtifactProvider,
 } from '@agent-device/contracts/observability';
 import type { DaemonRequest, DaemonResponse } from '../types.ts';
-import type { LeaseRegistry } from '../lease-registry.ts';
+import type { LeaseRegistry, ReleaseLeaseRequest } from '../lease-registry.ts';
 import type { SessionStore } from '../session-store.ts';
 import {
   isProxyLeaseScope,
@@ -21,7 +21,7 @@ import {
   leaseScopeToHeartbeatRequest,
   leaseScopeToReleaseRequest,
 } from '../../core/lease-scope.ts';
-import { AppError, createRequestCanceledError } from '@agent-device/kernel/errors';
+import { AppError, createRequestCanceledError, errorMessage } from '@agent-device/kernel/errors';
 import { LEASE_ALLOCATION_BUDGET_MS } from '../../core/command-descriptor/timeout-policy.ts';
 import { getRequestSignal, isRequestCanceled } from '../../request/cancel.ts';
 import { listDownloadableArtifacts } from '../artifact-tracking.ts';
@@ -75,7 +75,7 @@ export async function handleLeaseCommands(args: LeaseHandlerArgs): Promise<Daemo
           deadline: Date.now() + LEASE_ALLOCATION_BUDGET_MS,
         });
       } catch (error) {
-        releaseRegistryLease(leaseRegistry, lease);
+        leaseRegistry.releaseLease(leaseReleaseRequestFor(lease));
         throw error;
       }
       if (isRequestCanceled(req.meta?.requestId)) {
@@ -101,93 +101,103 @@ export async function handleLeaseCommands(args: LeaseHandlerArgs): Promise<Daemo
     }
     case 'lease_release': {
       const releaseRequest = leaseScopeToReleaseRequest(leaseScope);
-      const lease = leaseRegistry.getLease(releaseRequest);
-      const providerData = lease
-        ? await leaseLifecycleProvider?.release?.(lease, leaseLifecycleContext(req))
-        : undefined;
-      const result = leaseRegistry.releaseLease(releaseRequest);
+      const outcome = await releaseLease(
+        leaseRegistry,
+        leaseLifecycleProvider,
+        leaseRegistry.getLease(releaseRequest),
+        releaseRequest,
+        leaseLifecycleContext(req),
+      );
       return {
         ok: true,
-        data: { released: result.released, ...(providerData ? { provider: providerData } : {}) },
+        data: {
+          released: outcome.released,
+          ...(outcome.provider ? { provider: outcome.provider } : {}),
+        },
       };
     }
     default:
       return null;
   }
 }
 
-function releaseRegistryLease(leaseRegistry: LeaseRegistry, lease: DeviceLease): void {
-  leaseRegistry.releaseLease(
-    leaseScopeToReleaseRequest({
-      leaseId: lease.leaseId,
-      tenantId: lease.tenantId,
-      runId: lease.runId,
-      leaseBackend: lease.backend,
-      leaseProvider: lease.leaseProvider,
-      deviceKey: lease.deviceKey,
-      clientId: lease.clientId,
-    }),
-  );
+function leaseReleaseRequestFor(lease: DeviceLease): ReleaseLeaseRequest {
+  return leaseScopeToReleaseRequest({
+    leaseId: lease.leaseId,
+    tenantId: lease.tenantId,
+    runId: lease.runId,
+    leaseBackend: lease.backend,
+    leaseProvider: lease.leaseProvider,
+    deviceKey: lease.deviceKey,
+    clientId: lease.clientId,
+  });
+}
+
+type LeaseReleaseOutcome = {
+  /** The daemon's own lease record was released. */
+  released: boolean;
+  /** Provider release data (providerSessionId, warnings, cloudArtifacts…) when a provider held it. */
+  provider?: Record<string, unknown>;
+};
+
+/** THE release path: provider first (it still needs the lease record), then the registry. */
+async function releaseLease(
+  leaseRegistry: LeaseRegistry,
+  leaseLifecycleProvider: LeaseLifecycleProvider | undefined,
+  lease: DeviceLease | undefined,
+  request: ReleaseLeaseRequest,
+  context?: LeaseLifecycleContext,
+): Promise<LeaseReleaseOutcome> {
+  const provider = lease ? await leaseLifecycleProvider?.release?.(lease, context) : undefined;
+  return { released: leaseRegistry.releaseLease(request).released, provider };
 }
 
 /**
- * Releases a lease that finished allocating after its requester was gone, and
- * turns the outcome into the canceled-request error the (absent) requester
- * would have received. Release evidence is only claimed on a clean release: a
- * provider that could not delete its session (`warnings`) is reported as such,
- * with the identifiers an operator needs to stop it by hand.
+ * Releases a lease that finished allocating after its requester was gone and
+ * turns the outcome into the canceled-request error nobody is left to receive:
+ * a throwing provider release is folded into `releaseError` rather than raised,
+ * and the provider session counts as released only when it reported no
+ * warnings — otherwise the error names what an operator must stop by hand.
  */
 async function releaseAllocationForGoneRequester(
   lease: DeviceLease,
   leaseLifecycleProvider: LeaseLifecycleProvider | undefined,
   leaseRegistry: LeaseRegistry,
 ): Promise<AppError> {
-  const outcome = await releaseProviderLease(lease, leaseLifecycleProvider);
-  releaseRegistryLease(leaseRegistry, lease);
-  return canceledAllocationError(lease, outcome);
-}
-
-type ProviderReleaseOutcome = {
-  providerSessionId?: unknown;
-  warnings: unknown[];
-  releaseError?: string;
-};
-
-async function releaseProviderLease(
-  lease: DeviceLease,
-  leaseLifecycleProvider: LeaseLifecycleProvider | undefined,
-): Promise<ProviderReleaseOutcome> {
+  const request = leaseReleaseRequestFor(lease);
+  let outcome: LeaseReleaseOutcome;
+  let releaseError: string | undefined;
   try {
-    const released = await leaseLifecycleProvider?.release?.(lease);
-    return {
-      providerSessionId: released?.providerSessionId,
-      warnings: Array.isArray(released?.warnings) ? released.warnings : [],
-    };
+    outcome = await releaseLease(leaseRegistry, leaseLifecycleProvider, lease, request);
   } catch (error) {
-    return { warnings: [], releaseError: errorMessage(error) };
+    releaseError = errorMessage(error);
+    outcome = { released: leaseRegistry.releaseLease(request).released };
   }
+  return canceledAllocationError(lease, outcome, releaseError);
 }
 
-function canceledAllocationError(lease: DeviceLease, outcome: ProviderReleaseOutcome): AppError {
-  const { providerSessionId, warnings, releaseError } = outcome;
-  const released = releaseError === undefined && warnings.length === 0;
+function canceledAllocationError(
+  lease: DeviceLease,
+  outcome: LeaseReleaseOutcome,
+  releaseError: string | undefined,
+): AppError {
+  const providerSessionId = outcome.provider?.providerSessionId;
+  const warnings = Array.isArray(outcome.provider?.warnings) ? outcome.provider.warnings : [];
+  const providerReleased = releaseError === undefined && warnings.length === 0;
   return createRequestCanceledError({
     leaseId: lease.leaseId,
     leaseProvider: lease.leaseProvider,
+    released: outcome.released,
+    providerReleased,
     providerSessionId,
     ...(warnings.length > 0 ? { warnings } : {}),
     ...(releaseError !== undefined ? { releaseError } : {}),
-    released,
-    hint: released
+    hint: providerReleased
       ? 'The lease request was canceled while the provider was still allocating; the session it produced was released.'
       : `The lease request was canceled while the provider was still allocating, and the session it produced could NOT be confirmed released — it may still be running and billing. Stop provider session ${String(providerSessionId ?? '(unknown)')} for lease ${lease.leaseId} by hand.`,
   });
 }
 
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
 function leaseLifecycleContext(req: DaemonRequest): LeaseLifecycleContext {
   return {
     flags: req.flags,