@zlink-systems/framework 0.26.0 → 0.27.0

package/src/runtime/spots/index.ts

@@ -1,3 +1,4 @@
+import { dispatchReasonFromError } from '../diagnostics/dispatch-error-details';
 import type {
   ActorRef,
   RoutingId,
@@ -32,6 +33,7 @@ import {
   ZLinkMessage,
   ZLinkFrameworkException,
   ZLinkFrameworkErrorKind,
+  ZLinkFrameworkRuntimeState,
   ZLinkSpotCloseReason,
   ZLinkSpotKind
 } from '../../contracts';
@@ -48,6 +50,7 @@ import {
   runWithFlow,
   type ZLinkRuntimeEventPublisher
 } from '../diagnostics';
+import { diagnosticTextOrAbsent } from '../diagnostics/diagnostic-text';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import { SubmitResult } from '../backend/runtime-values';
 import {
@@ -59,10 +62,10 @@ import {
 } from '../foundation/service-runtime-contracts';
 import { zlinkMetadataByteLength, zlinkSerialWorkOptions } from '../execution/serial-work-size';
 import { ZLinkConfigurationException } from '../configuration';
+import { releaseApplicationJobPermitBeforeHandler } from '../application-jobs/application-job-queue-scope';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException,
-  internalFrameworkErrorKind,
   internalFrameworkWireReply
 } from '../framework-errors-internal';
 import type { ZLinkBackendSpot, ZLinkBackendSpotNode } from '../backend/contracts';
@@ -132,7 +135,7 @@ export { ZLinkRuntimeSpotPublisherTransport } from './spot-publisher-transport';
 import { ZLinkSpotActivationRegistry } from './spot-activation-registry';
 import type { ZLinkSpotActivation } from './spot-activation-state';
 import { ZLinkSpotActivationLifecycle, type ZLinkNativeSpotAuthority } from './spot-activation';
-import { ZLinkSpotActorMembership, type ZLinkActorJoinRollback } from './spot-actor-membership';
+import { ZLinkSpotActorMembership } from './spot-actor-membership';
 import { ZLinkFormalRemoteActorTransferRegistry } from './formal-remote-actor-transfer-registry';
 import {
   ZLinkFormalRemoteActorAdmissionRegistry,
@@ -204,6 +207,11 @@ export interface ZLinkSpotManagerOptions {
     actor: ZLinkActor,
     handoffBacklog?: readonly ZLinkActorHandoffPacket[]
   ) => Promise<void>;
+  readonly executeEntryActor?: <T>(
+    meshName: string,
+    actorId: string,
+    operation: () => Promise<T>
+  ) => Promise<T>;
   readonly actorCountProvider?: (spotId: RoutingId) => number;
   readonly userSpotExecutionMode?: (
     meshName: string,
@@ -217,7 +225,6 @@ export interface ZLinkSpotManagerOptions {
     readonly actorRef?: ActorRef;
     readonly spotId?: RoutingId;
   };
-  readonly actorBindingGenerationObserver?: (actorId: string, generation: bigint) => void;
   readonly channelClient?: ZLinkChannelClient;
   readonly fanoutClient?: ZLinkFanoutClient;
   readonly spotPublisherClient?: ZLinkSpotPublisherClient;
@@ -225,7 +232,6 @@ export interface ZLinkSpotManagerOptions {
   readonly routedTransport?: ZLinkSpotRoutedTransport;
   readonly addressTransport?: import('./spot-outbound').ZLinkSpotAddressTransport;
   readonly spotRouterChannelIdForMesh?: (meshName: string) => string;
-  readonly channelMeshNameForChannel?: (channelName: string) => string | undefined;
   readonly providerResolver?: ZLinkProviderResolver;
   readonly dispatchErrors?: ZLinkDispatchErrorReporter;
   readonly closeErrorSink?: import('../diagnostics/dispatch-error-port').ZLinkDispatchErrorSink;
@@ -242,19 +248,26 @@ export interface ZLinkSpotManagerOptions {
     meshName: string,
     spotId: RoutingId,
     onCommitted: () => void
-  ) => Promise<{ release(): Promise<void> } | undefined>;
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   readonly beginInstanceClosingAuthority?: (
     meshName: string,
     spotId: RoutingId,
-    onCommitted: () => void
-  ) => Promise<{ release(): Promise<void> } | undefined>;
+    onCommitted: () => void,
+    objectGeneration: bigint
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   /** Moves a local User Spot incarnation's authority to Closing for a context Close. */
   readonly beginUserClosingAuthority?: (
     meshName: string,
     spotId: RoutingId,
     objectGeneration: bigint,
     onCommitted: () => void
-  ) => Promise<{ release(): Promise<void> } | undefined>;
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
   readonly instanceSpotApplicationTargetProvider?: (
     meshName: string,
     spotId: RoutingId
@@ -284,13 +297,16 @@ export interface ZLinkSpotManagerOptions {
     readonly ownerLeaseGeneration: bigint;
   }) => Promise<{ readonly actorType: string }>;
   readonly actorLifecycleResolver?: (actorId: string) => ZLinkActor | undefined;
-  readonly detachedTaskRunner?: ZLinkDetachedTaskRunner;
+  readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
   readonly actorTransferRuntime?: ZLinkSpotActorTransferRuntime;
   readonly boundSessionRuntime?: ZLinkSpotBoundSessionRuntime;
   readonly actorHandoffRuntime?: ZLinkSpotActorHandoffRuntime;
   readonly metrics?: import('../diagnostics').ZLinkRuntimeMetrics;
   readonly admission?: ZLinkRuntimeAdmissionGate;
-  readonly statefulExecutionAllowed?: () => boolean;
+  readonly statefulExecution?: {
+    readonly admissionOpen: () => boolean;
+    readonly hostState: () => ZLinkFrameworkRuntimeState;
+  };
   readonly activationAdmission?: ZLinkActivationAdmission;
 }
 
@@ -299,11 +315,15 @@ interface ZLinkTargetSpotCloseOperation {
   readonly reason: ZLinkSpotCloseReason;
   readonly beginAuthority: (
     onCommitted: () => void
-  ) => Promise<{ release(): Promise<void> } | undefined>;
-  committed: boolean;
-  authority?: { release(): Promise<void> };
+  ) => Promise<
+    import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+  >;
+  authority?: import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority;
   authorityDecision?: Promise<void>;
   ready?: Promise<boolean>;
+  canExecuteApplication?(
+    record: import('../execution/serial-execution-queue').ZLinkSerialWorkRecord<unknown>
+  ): boolean;
 }
 
 export class DefaultZLinkSpotManager {
@@ -338,9 +358,10 @@ export class DefaultZLinkSpotManager {
     private readonly options: ZLinkSpotManagerOptions,
     timerClock?: import('./spot-timer').ZLinkTimerClock
   ) {
-    this.activations = new ZLinkSpotActivationRegistry(options.metrics, (meshName, spotId) =>
-      this.isSpotClosing(meshName, spotId)
-    );
+    if ((options.detachedTaskRunner as unknown) === undefined) {
+      throw new ZLinkConfigurationException('Spot manager requires a detached task runner.');
+    }
+    this.activations = new ZLinkSpotActivationRegistry(options.metrics);
     this.factories = new Set(options.spotFactories);
     this.workerRuntime = options.workerRuntime ?? new ZLinkWorkerRuntime();
     this.locationClaim = new ZLinkSpotLocationClaim({
@@ -350,7 +371,7 @@ export class DefaultZLinkSpotManager {
       nodeGenerationProvider: options.nodeGenerationProvider
     });
     this.routedSpotPackets = new ZLinkRoutedSpotPacketDispatch({
-      resolveActivation: (spotId) => this.activations.resolveUnique(spotId),
+      resolveActivation: (spotId) => this.resolveApplicationActivation(spotId),
       claimApplicationWork:
         options.admission === undefined
           ? undefined
@@ -359,9 +380,6 @@ export class DefaultZLinkSpotManager {
       dispatchErrors: options.dispatchErrors
     });
     this.actorMembership = new ZLinkSpotActorMembership({
-      isSpotClosing: (activation) =>
-        this.isSpotClosing(activation.meshName, activation.spotId) ||
-        this.activations.resolve(activation.meshName, activation.spotId) !== activation,
       resolveActivation: (spotId, meshName) =>
         meshName === undefined
           ? this.activations.resolveUnique(spotId)
@@ -412,14 +430,11 @@ export class DefaultZLinkSpotManager {
       boundSessionRuntime: options.boundSessionRuntime,
       actorHandoffRuntime: options.actorHandoffRuntime,
       admission: options.admission,
-      statefulExecutionAllowed: options.statefulExecutionAllowed,
+      statefulExecutionAllowed: options.statefulExecution?.admissionOpen,
       leaveActor: (spotId, actor, signal, meshName) =>
         this.actorMembership.leaveActor(spotId, actor, signal, meshName),
       requestContextClose: (activation, objectGeneration, signal) =>
         this.closeFromContext(activation, objectGeneration, signal),
-      isSpotClosing: (activation) =>
-        this.isSpotClosing(activation.meshName, activation.spotId) ||
-        this.activations.resolve(activation.meshName, activation.spotId) !== activation,
       registerActivation: (activation) => {
         this.activations.register(activation);
         this.scheduleIdleSweep();
@@ -597,10 +612,6 @@ export class DefaultZLinkSpotManager {
         await awaitWithAbort(pendingClose, signal);
         continue;
       }
-      if (closeOperation?.committed === true) {
-        await awaitWithAbort(this.closeWithReason(meshName, spotId), signal);
-        continue;
-      }
       const closing = this.activations.closingOperation(meshName, spotId);
       if (closing !== undefined) {
         await awaitWithAbort(closing.ready, signal);
@@ -694,31 +705,49 @@ export class DefaultZLinkSpotManager {
   }
 
   isInstanceMaterialized(meshName: string, instanceType: string, spotId: RoutingId): boolean {
-    const activation = this.activations.resolve(meshName, spotId);
+    const activation = this.resolveApplicationActivation(spotId, meshName);
     return (
       activation !== undefined &&
       activation.spotType === this.requireInstanceFactory(meshName, instanceType)
     );
   }
 
+  private resolveApplicationActivation(
+    spotId: RoutingId,
+    meshName?: string
+  ): ZLinkSpotActivation | undefined {
+    const current =
+      meshName === undefined
+        ? this.activations.resolveUnique(spotId)
+        : this.activations.resolve(meshName, spotId);
+    if (current !== undefined) return current;
+    if (meshName !== undefined)
+      return this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.activation;
+    for (const operation of this.closeOperations.values()) {
+      if (String(operation.activation.spotId) === String(spotId)) return operation.activation;
+    }
+    return undefined;
+  }
+
   isInstanceMaterializing(meshName: string, spotId: RoutingId): boolean {
     const prefix = instanceMaterializationPrefix(meshName, spotId);
-    return (this.pendingInstanceMaterializationsByPrefix.get(prefix)?.size ?? 0) > 0;
+    return (
+      (this.pendingInstanceMaterializationsByPrefix.get(prefix)?.size ?? 0) > 0 ||
+      this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.authority !== undefined
+    );
   }
 
   isSpotClosing(meshName: string, spotId: RoutingId): boolean {
-    const key = `${meshName}\0${String(spotId)}`;
-    return this.closeOperations.get(key)?.committed === true;
+    return (
+      this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.authority !== undefined ||
+      this.activations.activationForClose(meshName, spotId)?.executionBarrier.isCloseSealed === true
+    );
   }
 
   pendingSpotCloseDecision(meshName: string, spotId: RoutingId): Promise<void> | undefined {
     return this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.authorityDecision;
   }
 
-  isInstanceClosing(meshName: string, spotId: RoutingId): boolean {
-    return this.closeOperations.has(`${meshName}\0${String(spotId)}`);
-  }
-
   async discardInstance(meshName: string, spotId: RoutingId): Promise<void> {
     const activation = this.activations.resolve(meshName, spotId);
     if (activation === undefined) return;
@@ -910,13 +939,10 @@ export class DefaultZLinkSpotManager {
             throw error;
           }
         };
-        this.options.detachedTaskRunner?.runDetached(
+        this.options.detachedTaskRunner.runDetached(
           `instance idle eviction ${String(activation.spotId)}`,
           run
         );
-        if (this.options.detachedTaskRunner === undefined) {
-          void run().catch(() => undefined);
-        }
       }
     } finally {
       this.idleSweepRunning = false;
@@ -1010,8 +1036,8 @@ export class DefaultZLinkSpotManager {
     requireMeshName(meshName);
     const args = normalizeSpotCreateArgs(requestOrSignal, signal);
     throwIfAborted(args.signal);
+    this.options.admission?.requireRequest('SPOT create', meshName);
     const operation = this.activations.getOrBegin(meshName, spotType, spotId, async () => {
-      this.options.admission?.requireRequest('SPOT create', meshName);
       const release = await this.options.activationAdmission?.acquire(meshName, args.signal);
       const ownedRequest =
         args.request === undefined
@@ -1036,12 +1062,16 @@ export class DefaultZLinkSpotManager {
 
   async find(meshName: string, spotId: RoutingId): Promise<ZLinkSpotInfo | null> {
     requireMeshName(meshName);
-    return this.activations.has(meshName, spotId) ? { spotId } : null;
+    return this.activations.has(meshName, spotId) && !this.isSpotClosing(meshName, spotId)
+      ? { spotId }
+      : null;
   }
 
   async list(meshName: string): Promise<readonly ZLinkSpotInfo[]> {
     requireMeshName(meshName);
-    return this.activations.list(meshName);
+    return this.activations
+      .list(meshName)
+      .filter(({ spotId }) => !this.isSpotClosing(meshName, spotId));
   }
 
   async drainForShutdown(meshName: string, signal?: AbortSignal, deadline?: Date): Promise<void> {
@@ -1073,7 +1103,9 @@ export class DefaultZLinkSpotManager {
   async closeUserWithAuthority(
     meshName: string,
     spotId: RoutingId,
-    beginAuthority: (onCommitted: () => void) => Promise<{ release(): Promise<void> }>,
+    beginAuthority: (
+      onCommitted: () => void
+    ) => Promise<import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority>,
     signal?: AbortSignal
   ): Promise<boolean> {
     return await this.closeWithReason(
@@ -1128,7 +1160,9 @@ export class DefaultZLinkSpotManager {
     deadline?: Date,
     beginUserAuthority?: (
       onCommitted: () => void
-    ) => Promise<{ release(): Promise<void> } | undefined>
+    ) => Promise<
+      import('../locations/spot-location-claims').ZLinkInstanceClosingAuthority | undefined
+    >
   ): Promise<boolean> {
     requireMeshName(meshName);
     const key = `${meshName}\0${String(spotId)}`;
@@ -1146,14 +1180,20 @@ export class DefaultZLinkSpotManager {
           `User Spot '${String(spotId)}' Close requires its authority owner.`
         );
       }
+      const domain = activation.domain;
       const beginAuthority =
         beginUserAuthority ??
-        (activation.domain.kind === 'instance' &&
+        (domain.kind === 'instance' &&
         reason === ZLinkSpotCloseReason.ExplicitClose &&
         this.options.beginInstanceClosingAuthority !== undefined
           ? (onCommitted) =>
-              this.options.beginInstanceClosingAuthority!(meshName, spotId, onCommitted)
-          : activation.domain.kind === 'instance' &&
+              this.options.beginInstanceClosingAuthority!(
+                meshName,
+                spotId,
+                onCommitted,
+                domain.objectGeneration
+              )
+          : domain.kind === 'instance' &&
               reason === ZLinkSpotCloseReason.IdleEvicted &&
               this.options.beginInstanceIdleClosingAuthority !== undefined
             ? (onCommitted) =>
@@ -1165,15 +1205,24 @@ export class DefaultZLinkSpotManager {
       operation = {
         activation,
         reason,
-        beginAuthority,
-        committed: false
+        beginAuthority
       };
+      if (reason === ZLinkSpotCloseReason.ExplicitClose) {
+        operation.canExecuteApplication = (record) => {
+          const context = record.context as
+            import('./spot-serial-turn-executor').ZLinkSpotApplicationTurnContext | undefined;
+          return context === undefined;
+        };
+      }
       this.closeOperations.set(key, operation);
     }
     if (operation.ready === undefined) {
       const active = operation;
-      const run = active.activation.serial.executeLifecycleOperation(() =>
-        this.runCloseOperation(meshName, spotId, active, signal, deadline)
+      const run = active.activation.serial.executeControlLifecycleOperation(
+        () => this.runCloseOperation(meshName, spotId, active, signal, deadline),
+        active.canExecuteApplication === undefined
+          ? undefined
+          : (active as import('../execution/serial-execution-queue').ZLinkSerialLifecycleContext)
       );
       active.ready = run.finally(() => {
         active.ready = undefined;
@@ -1192,20 +1241,100 @@ export class DefaultZLinkSpotManager {
     signal?: AbortSignal,
     deadline?: Date
   ): Promise<boolean> {
-    const began = await this.beginCloseAuthority(meshName, spotId, operation, signal);
-    if (!began) return false;
-    const seal = operation.activation.sealExecution(true);
-    await this.activationLifecycle.sealForClose(operation.activation, seal);
+    const seal = await this.beginCloseAuthority(meshName, spotId, operation, signal);
+    if (seal === undefined) return false;
+    if (seal !== true) {
+      await this.activationLifecycle.sealForClose(operation.activation, seal);
+    } else {
+      await operation.activation.executionBarrier.waitForStartedTurns(signal);
+    }
     const closingFailure = await this.activationLifecycle.cleanupClosedActivation(
       operation.activation,
       operation.reason,
       deadline
     );
-    await operation.authority?.release();
-    // The incarnation has no further lifecycle item once its authority is
-    // released, so its lifecycle lane admission closes with this Close.
-    operation.activation.serial.closeAdmission();
     this.activations.finishClose(meshName, spotId);
+    const intentRecords: unknown[] = [];
+    operation.activation.serial.visitPendingApplication((record) => {
+      const context = record.context as
+        import('./spot-serial-turn-executor').ZLinkSpotApplicationTurnContext | undefined;
+      if (context?.replay !== undefined) intentRecords.push(record);
+    });
+    const hasIntent = intentRecords.length > 0;
+    // Spot messaging §7 step 3: with no Instance intent message waiting, the
+    // release decision also ends this Instance incarnation's admission in this turn.
+    if (!hasIntent && operation.activation.domain.kind === 'instance')
+      operation.activation.serial.closeAdmission();
+    const hostState = this.options.statefulExecution?.hostState();
+    const intentFailure = !hasIntent
+      ? undefined
+      : hostState === ZLinkFrameworkRuntimeState.Draining
+        ? createInternalFrameworkException(
+            ZLinkFrameworkInternalErrorKind.RuntimeShutdown,
+            'Instance intent cannot continue while the host is draining.'
+          )
+        : hostState === ZLinkFrameworkRuntimeState.Relocating ||
+            hostState === ZLinkFrameworkRuntimeState.Relocated ||
+            this.options.statefulExecution?.admissionOpen() === false ||
+            (operation.activation.executionBarrier.isSealed &&
+              !operation.activation.executionBarrier.isCloseSealed)
+          ? createInternalFrameworkException(
+              ZLinkFrameworkInternalErrorKind.SpotMoving,
+              'Instance intent cannot continue on an unavailable or relocating owner.'
+            )
+          : undefined;
+    if (
+      operation.reason === ZLinkSpotCloseReason.ExplicitClose &&
+      hasIntent &&
+      intentFailure === undefined &&
+      operation.authority?.reincarnate !== undefined
+    ) {
+      try {
+        await operation.authority.reincarnate(async (authority) => {
+          await this.activationLifecycle.materializeInstance(
+            meshName,
+            authority.stableType,
+            operation.activation.spotType as Type<ZLinkInstanceSpot>,
+            spotId,
+            authority.objectGeneration,
+            signal,
+            operation.activation
+          );
+        });
+        // The new incarnation shares this serial owner and admits membership work again.
+        operation.activation.serial.setLifecycleAdmissionClosed(false);
+      } catch (error) {
+        const initialized = this.activations.resolve(meshName, spotId);
+        if (initialized !== undefined && initialized !== operation.activation) {
+          await this.activationLifecycle.cleanupFailedIncarnation(initialized);
+        }
+        this.activations.finishClose(meshName, spotId);
+        operation.activation.serial.visitPendingApplication((record) => {
+          const context = record.context as
+            import('./spot-serial-turn-executor').ZLinkSpotApplicationTurnContext | undefined;
+          if (context?.replay !== undefined) record.operation = () => context.replay!(error);
+        });
+        operation.activation.serial.closeAdmission();
+        throw error;
+      }
+    } else {
+      await operation.authority?.release();
+      operation.activation.serial.closeAdmission();
+      if (!operation.activation.executionBarrier.isSealed) {
+        const closed = operation.activation.sealExecution('close');
+        operation.activation.commitExecutionSeal(closed);
+      }
+    }
+    if (operation.reason === ZLinkSpotCloseReason.ExplicitClose) {
+      operation.activation.serial.visitPendingApplication((record) => {
+        const context = record.context as
+          import('./spot-serial-turn-executor').ZLinkSpotApplicationTurnContext | undefined;
+        if (context?.replay !== undefined) {
+          record.operation =
+            intentFailure === undefined ? context.replay : () => context.replay!(intentFailure);
+        }
+      });
+    }
     this.closeOperations.delete(`${meshName}\0${String(spotId)}`);
     // An OnClosing failure never changes a Close result; host shutdown alone
     // reports it as its teardown outcome after cleanup has finished.
@@ -1220,9 +1349,11 @@ export class DefaultZLinkSpotManager {
     spotId: RoutingId,
     operation: ZLinkTargetSpotCloseOperation,
     signal?: AbortSignal
-  ): Promise<boolean> {
+  ): Promise<import('../execution').ZLinkExecutionBarrierSeal | true | undefined> {
+    // Spot messaging §4 step 12 with §7 step 1: a Close of any reason begins its
+    // Closing CAS only after the first terminal record of an activated message.
     await this.options.instanceSpotApplicationQuiescenceProvider?.(meshName, spotId, signal);
-    if (!operation.activation.canClose(operation.reason)) return false;
+    if (!operation.activation.canClose(operation.reason)) return undefined;
     if (operation.activation.executionBarrier.isSealed) {
       throw createInternalFrameworkException(
         ZLinkFrameworkInternalErrorKind.SpotMoving,
@@ -1230,9 +1361,15 @@ export class DefaultZLinkSpotManager {
         true
       );
     }
+    let seal: import('../execution').ZLinkExecutionBarrierSeal | true | undefined;
     const authorityPromise = Promise.resolve().then(() =>
       operation.beginAuthority(() => {
-        operation.committed = true;
+        if (operation.reason === ZLinkSpotCloseReason.ExplicitClose) {
+          operation.activation.serial.setLifecycleAdmissionClosed(true);
+          seal = true;
+        } else {
+          seal = operation.activation.sealExecution('close');
+        }
       })
     );
     operation.authorityDecision = authorityPromise.then(
@@ -1240,12 +1377,12 @@ export class DefaultZLinkSpotManager {
       () => undefined
     );
     const authority = await authorityPromise;
-    if (authority === undefined) return false;
+    if (authority === undefined) return undefined;
     operation.authority = authority;
-    if (!this.isSpotClosing(meshName, spotId)) {
+    if (seal === undefined) {
       throw new Error(`Spot '${String(spotId)}' Closing authority did not confirm its commit.`);
     }
-    return true;
+    return seal;
   }
 
   async executeOnSpot<TSpot extends ZLinkSpot, TResult>(
@@ -1311,15 +1448,19 @@ export class DefaultZLinkSpotManager {
     spotId: RoutingId,
     actor: ZLinkActor,
     request: Message,
-    commit: (
-      spot: ZLinkSpot
-    ) => Promise<ZLinkActorJoinRollback | void> | ZLinkActorJoinRollback | void,
+    commit: (spot: ZLinkSpot) => Promise<void> | void,
     signal?: AbortSignal,
     leaveSource?: () => Promise<void>,
     contentType = 'application/json'
   ): Promise<ZLinkSpotActorJoinResult> {
     const meshName = this.activations.resolveUnique(spotId)?.meshName;
     this.options.admission?.requireRequest('Actor join admission', meshName);
+    if (meshName !== undefined && this.isSpotClosing(meshName, spotId)) {
+      throw createInternalFrameworkException(
+        ZLinkFrameworkInternalErrorKind.RequestRejected,
+        `Spot '${String(spotId)}' is closing.`
+      );
+    }
     return await this.actorMembership.admitActorJoin(
       spotId,
       actor,
@@ -1558,7 +1699,7 @@ export class DefaultZLinkSpotManager {
     let target = this.options.instanceSpotApplicationTargetProvider?.(meshName, spotId);
     if (target === undefined) return;
     for (;;) {
-      const current = this.activations.resolve(meshName, spotId);
+      const current = this.resolveApplicationActivation(spotId, meshName);
       if (
         current !== undefined &&
         current.objectGeneration === target.objectGeneration &&
@@ -1612,7 +1753,7 @@ export class DefaultZLinkSpotManager {
       );
       try {
         await this.ensureInstanceApplicationActivation(meshName, spotId);
-        const activation = this.activations.resolve(meshName, spotId);
+        const activation = this.resolveApplicationActivation(spotId, meshName);
         if (activation === undefined || activation.domain.kind !== 'instance') {
           throw new ZLinkConfigurationException(
             `MeshNode Instance Spot target '${String(spotId)}' is not active.`
@@ -1637,12 +1778,39 @@ export class DefaultZLinkSpotManager {
           channelName: envelope.header.channelName,
           contentType: envelope.header.contentType,
           awaitFirstHandlerTurn: record.kind === ReceiveKind.InstanceSpotActivation,
+          activationRecord: record,
+          onOneWayError:
+            this.options.dispatchErrors?.captureEnabled() === true
+              ? (error: unknown) =>
+                  this.reportInstanceDispatchFailure(
+                    meshName,
+                    spotId,
+                    record,
+                    envelope,
+                    false,
+                    error
+                  )
+              : undefined,
           workOptions: zlinkSerialWorkOptions(
             envelope.payload.byteLength,
             record.applicationMetadata?.byteLength ??
               zlinkMetadataByteLength(envelope.header.metadata)
           )
         };
+        // Spot messaging §7 step 3: an Instance intent request that reaches an
+        // incarnation whose Close ended admission is refused before admission
+        // with the owner fence terminal, so its caller re-reads authority.
+        const instanceIntent =
+          record.activationRecord?.activation === 'missing' ||
+          (record.activationRecord?.activation === 'ready' &&
+            record.activationRecord.instanceIntent);
+        const refusal = activation.serial.applicationAdmissionRefusal(instanceIntent === true);
+        if (request && refusal !== undefined && record.replyFailure !== undefined) {
+          this.reportInstanceDispatchFailure(meshName, spotId, record, envelope, request, refusal);
+          const terminal = internalFrameworkWireReply(refusal);
+          requireMeshSpotReply(record.replyFailure(terminal.terminalResult, terminal.failureCode));
+          return;
+        }
         this.traceInstanceMessage(
           ZLinkMessageFlowOutcome.Admitted,
           meshName,
@@ -1707,7 +1875,8 @@ export class DefaultZLinkSpotManager {
           target?.stableType
         );
       } catch (error) {
-        const reason = instanceDispatchErrorReason(error);
+        this.reportInstanceDispatchFailure(meshName, spotId, record, envelope, request, error);
+        const reason = dispatchReasonFromError(error);
         if (!request) {
           this.traceInstanceMessage(
             ZLinkMessageFlowOutcome.Dropped,
@@ -1721,29 +1890,42 @@ export class DefaultZLinkSpotManager {
           );
           return;
         }
-        this.options.dispatchErrors?.report({
-          surface: ZLinkDispatchErrorSurface.InstanceSpot,
-          messageKind: ZLinkDispatchMessageKind.Request,
-          packetName: envelope.packetName,
-          channelName: envelope.header.channelName,
-          meshName,
-          correlationId: envelope.header.correlationId ?? undefined,
-          sourceRid: record.sourceNodeRid === null ? undefined : String(record.sourceNodeRid),
-          spotId: String(spotId),
-          instanceSpotType: this.options.instanceSpotApplicationTargetProvider?.(meshName, spotId)
-            ?.stableType,
-          activationState: 'closing',
-          flowId: envelope.header.flowId,
-          flowOrigin: envelope.header.flowOrigin,
-          reason,
-          action: ZLinkDispatchErrorAction.ReplyError,
-          error
-        });
+
         requireMeshSpotReply(record.reply(encodeChannelErrorReplyParts(envelope.header, error)));
       }
     });
   }
 
+  private reportInstanceDispatchFailure(
+    meshName: string,
+    spotId: RoutingId,
+    record: ReceiveRecord,
+    envelope: ReturnType<typeof decodeChannelEnvelope>,
+    request: boolean,
+    error: unknown
+  ): void {
+    const reporter = this.options.dispatchErrors;
+    if (reporter?.captureEnabled() !== true) return;
+    reporter.report({
+      surface: ZLinkDispatchErrorSurface.InstanceSpot,
+      messageKind: request ? ZLinkDispatchMessageKind.Request : ZLinkDispatchMessageKind.Send,
+      packetName: envelope.packetName,
+      channelName: envelope.header.channelName,
+      meshName,
+      correlationId: envelope.header.correlationId ?? undefined,
+      sourceRid: record.sourceNodeRid === null ? undefined : String(record.sourceNodeRid),
+      spotId: String(spotId),
+      instanceSpotType: this.options.instanceSpotApplicationTargetProvider?.(meshName, spotId)
+        ?.stableType,
+      activationState: 'closing',
+      flowId: envelope.header.flowId,
+      flowOrigin: envelope.header.flowOrigin,
+      reason: dispatchReasonFromError(error),
+      action: request ? ZLinkDispatchErrorAction.ReplyError : ZLinkDispatchErrorAction.Drop,
+      error
+    });
+  }
+
   private traceInstanceMessage(
     outcome: ZLinkMessageFlowOutcome,
     meshName: string,
@@ -1796,9 +1978,6 @@ export class DefaultZLinkSpotManager {
       throw new ZLinkConfigurationException('MeshNode Actor record is missing its Actor owner.');
     }
     const request = record.kind === ReceiveKind.ActorRequest;
-    if (record.sourceBindingGeneration > 0n) {
-      this.options.actorBindingGenerationObserver?.(actor.actorId, record.sourceBindingGeneration);
-    }
     const resolvedOwner = this.options.actorDispatchOwnerResolver?.(actor.actorId);
     const resolvedActorRef = resolvedOwner?.actorRef ?? {
       actorId: actor.actorId,
@@ -1889,10 +2068,7 @@ export class DefaultZLinkSpotManager {
         record.reply(
           this.encodeMeshActorReply(record.parts[0], ZLinkStreamMessageKind.Error, {
             message: error instanceof Error ? error.message : String(error),
-            kind:
-              error instanceof ZLinkFrameworkException
-                ? error.kind
-                : ZLinkFrameworkErrorKind.InternalFailure
+            kind: spotActorFailureKind(error)
           })
         )
       );
@@ -1906,37 +2082,51 @@ export class DefaultZLinkSpotManager {
   ): Promise<void> {
     const spotId = owner.spotId as unknown as RoutingId | null;
     const activation = spotId === null ? undefined : this.activations.resolve(meshName, spotId);
-    if (activation?.domain.kind === 'user') {
-      await activation.serial.executeLifecycleOperation(async () => {
+    const replyState = { targetCommitPublished: false };
+    try {
+      if (
+        record.kindData?.kind === 'actorControl' &&
+        record.kindData.canonicalActorJoin !== undefined
+      ) {
+        const entrySpotId = this.options.entryNodeRidProvider?.() ?? this.options.entryNodeRid;
         if (
-          this.isSpotClosing(meshName, activation.spotId) ||
-          this.activations.resolve(meshName, activation.spotId) !== activation
+          spotId !== null && entrySpotId !== undefined && String(spotId) === String(entrySpotId)
+            ? this.options.dispatchEntryActorJoin === undefined
+            : activation === undefined
         ) {
-          const rejection = createInternalFrameworkException(
-            ZLinkFrameworkInternalErrorKind.RequestRejected,
-            `User Spot '${String(spotId)}' is closing.`
+          throw createInternalFrameworkException(
+            ZLinkFrameworkInternalErrorKind.RouteNotConnected,
+            `Spot '${String(spotId)}' is not active on this node.`
           );
-          if (record.replyFailure !== undefined) {
-            const terminal = internalFrameworkWireReply(rejection);
-            requireMeshSpotReply(
-              record.replyFailure(terminal.terminalResult, terminal.failureCode)
-            );
-          } else {
-            requireMeshSpotReply(record.replyActorJoin(1, []));
-          }
-          return;
         }
-        await this.dispatchMeshActorJoinCore(meshName, owner, record);
-      });
-      return;
+      }
+      if (activation?.domain.kind === 'user') {
+        await activation.serial.executeLifecycleOperation(() =>
+          this.dispatchMeshActorJoinCore(meshName, owner, record, replyState)
+        );
+        return;
+      }
+      await this.dispatchMeshActorJoinCore(meshName, owner, record, replyState);
+    } catch (error) {
+      if (replyState.targetCommitPublished || record.replyFailure === undefined) throw error;
+      const failure =
+        error instanceof ZLinkFrameworkException
+          ? error
+          : createInternalFrameworkException(
+              ZLinkFrameworkInternalErrorKind.RequestFailed,
+              'Actor Join target admission failed.',
+              error
+            );
+      const terminal = internalFrameworkWireReply(failure);
+      requireMeshSpotReply(record.replyFailure(terminal.terminalResult, terminal.failureCode));
     }
-    await this.dispatchMeshActorJoinCore(meshName, owner, record);
   }
 
   private async dispatchMeshActorJoinCore(
     meshName: string,
     owner: ReadyRecord,
-    record: ReceiveRecord
+    record: ReceiveRecord,
+    replyState: { targetCommitPublished: boolean }
   ): Promise<void> {
     const spotId = owner.spotId as unknown as RoutingId | null;
     const control = record.kindData;
@@ -2001,14 +2191,10 @@ export class DefaultZLinkSpotManager {
       admissionRecord = provisional.record;
       canonicalAdmissionCreated = provisional.created;
       try {
+        releaseApplicationJobPermitBeforeHandler();
         canonicalActorType = (await resolver({ actorId, ...control.canonicalActorJoin })).actorType;
       } catch (error) {
         this.formalRemoteActorAdmissions.fail(control.canonicalActorJoin.handoffId, error);
-        if (error instanceof ZLinkFrameworkException && record.replyFailure !== undefined) {
-          const terminal = internalFrameworkWireReply(error);
-          requireMeshSpotReply(record.replyFailure(terminal.terminalResult, terminal.failureCode));
-          return;
-        }
         throw error;
       }
     }
@@ -2037,7 +2223,6 @@ export class DefaultZLinkSpotManager {
     let admissionOutcome: ZLinkFormalRemoteActorAdmissionResult | undefined;
     let accepted = false;
     let committedAdmissionReplay = isRemoteCommit && admissionRecord?.state === 'committed';
-    let targetCommitPublished: boolean | undefined;
     const actorJoinIsCurrent = (): boolean =>
       (record.deadlineUnixMs === undefined || record.deadlineUnixMs > BigInt(Date.now())) &&
       (record.isPending?.() ?? true);
@@ -2098,14 +2283,12 @@ export class DefaultZLinkSpotManager {
         if (canonicalAdmissionCreated) {
           if (targetsEntrySpot) {
             admissionOutcome = {
-              accepted: this.options.dispatchEntryActorJoin !== undefined,
+              accepted: true,
               actorRef
             };
-          } else if (activation === undefined) {
-            admissionOutcome = { accepted: false, actorRef };
           } else {
-            const response: ZLinkSpotActorJoinResult = await activation.serial.execute(async () =>
-              activation.spot.onActorJoin(
+            const response: ZLinkSpotActorJoinResult = await activation!.serial.execute(async () =>
+              activation!.spot.onActorJoin(
                 actorRef.actorId,
                 wrapFrameworkPayloadMessage(
                   callbackRequest!,
@@ -2429,21 +2612,6 @@ export class DefaultZLinkSpotManager {
           return;
         }
       }
-      if (
-        accepted &&
-        transferRequest !== undefined &&
-        this.options.actorTransferRuntime !== undefined &&
-        !isRemoteAdmission
-      ) {
-        // A lightweight Core actor-join notification can create the Actor
-        // before the formal transfer request reaches this branch. Preserve
-        // the full relocation fence in that race so a later Session bind
-        // refresh cannot erase the seal.
-        this.options.actorTransferRuntime.rememberRoutedActorTransferTarget(
-          actorId,
-          transferRequest.remoteBoundSessionTarget
-        );
-      }
       if (
         accepted &&
         actor !== undefined &&
@@ -2456,7 +2624,8 @@ export class DefaultZLinkSpotManager {
           spotId,
           transferId: transferRequest.transferId,
           handoffBacklog: transferRequest.handoffBacklog,
-          deferredJoinCompletion
+          deferredJoinCompletion,
+          sealedSession: transferRequest.remoteBoundSessionTarget
         });
         if (isRemoteCommit && admissionRecord !== undefined) {
           this.formalRemoteActorAdmissions.markCommitted(transferRequest.transferId, actor);
@@ -2476,7 +2645,7 @@ export class DefaultZLinkSpotManager {
           // Core commits the target membership while it accepts this reply.
           // From this call onward a later callback/transport failure is
           // post-commit and must not roll the materialized Actor back.
-          targetCommitPublished = true;
+          replyState.targetCommitPublished = true;
         }
         requireMeshSpotReply(joinReplyResult);
         return true;
@@ -2501,60 +2670,85 @@ export class DefaultZLinkSpotManager {
           if (!replyActorJoin()) return;
           const commitEntryTransfer = async (): Promise<void> => {
             try {
-              await this.options.dispatchEntryActorJoin?.(meshName, entryActor, []);
-            } finally {
-              this.formalRemoteTransfers.completeTargetLifecycle(
-                entryActor.context.actorId,
-                pendingTransfer.transferId
-              );
-            }
-            const sourceLeaveSubmitted = await pendingTransfer.sourceLeaveSubmitted;
-            if (!sourceLeaveSubmitted) {
-              throw new Error(
-                `Actor '${entryActor.context.actorId}' source authority commit failed before leave submission.`
-              );
-            }
-            const handoffResults = await replayActorHandoffBacklog(
-              pendingTransfer.handoffBacklog,
-              async (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => {
-                if (this.options.dispatchEntryActorPacket === undefined) {
-                  throw new Error(
-                    'Entry Spot saved handoff replay requires its Actor packet runtime.'
-                  );
-                }
-                return await this.options.dispatchEntryActorPacket(
+              try {
+                await this.options.dispatchEntryActorJoin?.(meshName, entryActor, []);
+              } finally {
+                this.formalRemoteTransfers.completeTargetLifecycle(
                   entryActor.context.actorId,
-                  parts,
-                  returnResponse,
-                  remoteBoundSessionTarget,
-                  fallbackActorRef
+                  pendingTransfer.transferId
                 );
-              },
-              (index) =>
-                this.options.runtimeEventPublisher?.publish({
-                  sourceName: 'zlink.framework.actor-handoff',
-                  timestamp: new Date(),
-                  marker: 'backlog_enqueued',
-                  actorId: entryActor.context.actorId,
-                  index
-                })
-            );
-            const failedHandoff = handoffResults.find((result) => !result.ok);
-            if (failedHandoff !== undefined) {
-              throw new Error(
-                `Actor '${entryActor.context.actorId}' saved Entry handoff packet ` +
-                  `${failedHandoff.index} failed: ${failedHandoff.error ?? 'unknown error'}.`
+              }
+              const sourceLeaveSubmitted = await pendingTransfer.sourceLeaveSubmitted;
+              if (!sourceLeaveSubmitted) {
+                throw new Error(
+                  `Actor '${entryActor.context.actorId}' source authority commit failed before leave submission.`
+                );
+              }
+              const handoffResults = await replayActorHandoffBacklog(
+                pendingTransfer.handoffBacklog,
+                async (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => {
+                  if (this.options.dispatchEntryActorPacket === undefined) {
+                    throw new Error(
+                      'Entry Spot saved handoff replay requires its Actor packet runtime.'
+                    );
+                  }
+                  return await this.options.dispatchEntryActorPacket(
+                    entryActor.context.actorId,
+                    parts,
+                    returnResponse,
+                    remoteBoundSessionTarget,
+                    fallbackActorRef
+                  );
+                },
+                (index) =>
+                  this.options.runtimeEventPublisher?.publish({
+                    sourceName: 'zlink.framework.actor-handoff',
+                    timestamp: new Date(),
+                    marker: 'backlog_enqueued',
+                    actorId: entryActor.context.actorId,
+                    index
+                  })
+              );
+              const failedHandoff = handoffResults.find((result) => !result.ok);
+              if (failedHandoff !== undefined) {
+                throw new Error(
+                  `Actor '${entryActor.context.actorId}' saved Entry handoff packet ` +
+                    `${failedHandoff.index} failed: ${diagnosticTextOrAbsent(failedHandoff.error)}.`
+                );
+              }
+            } catch (error) {
+              const completion = pendingTransfer.deferredJoinCompletion;
+              if (completion !== undefined) {
+                await this.options.actorTransferRuntime?.deliverDeferredJoinCompletion(
+                  {
+                    ...completion,
+                    status: 'failed',
+                    kind: spotActorFailureKind(error)
+                  },
+                  entryActor,
+                  completion.actor,
+                  (operation) =>
+                    this.options.executeEntryActor!(meshName, entryActor.context.actorId, operation)
+                );
+              }
+              throw error;
+            }
+            const completion = pendingTransfer.deferredJoinCompletion;
+            if (completion !== undefined) {
+              await this.options.actorTransferRuntime?.deliverDeferredJoinCompletion(
+                completion,
+                entryActor,
+                completion.actor,
+                (operation) =>
+                  this.options.executeEntryActor!(meshName, entryActor.context.actorId, operation)
               );
             }
             this.formalRemoteTransfers.delete(entryActor.context.actorId);
           };
-          this.options.detachedTaskRunner?.runDetached(
+          this.options.detachedTaskRunner.runDetached(
             `actor Entry Spot transfer ${entryActor.context.actorId}`,
             commitEntryTransfer
           );
-          if (this.options.detachedTaskRunner === undefined) {
-            void commitEntryTransfer().catch(() => undefined);
-          }
         }
       } else {
         if (!replyActorJoin()) return;
@@ -2563,10 +2757,10 @@ export class DefaultZLinkSpotManager {
       if (control.canonicalActorJoin !== undefined) {
         this.formalRemoteActorAdmissions.fail(control.canonicalActorJoin.handoffId, error);
       }
-      if (targetCommitPublished !== true) {
+      if (!replyState.targetCommitPublished) {
         this.formalRemoteTransfers.delete(actorId);
       }
-      if (materialized && targetCommitPublished !== true) {
+      if (materialized && !replyState.targetCommitPublished) {
         await this.options.actorTransferRuntime?.rollbackRoutedActor(actor!);
       }
       throw error;
@@ -2601,11 +2795,10 @@ export class DefaultZLinkSpotManager {
         actorId !== undefined &&
         this.formalRemoteTransfers.get(actorId) !== undefined
       ) {
-        this.options.detachedTaskRunner?.runDetached(
+        this.options.detachedTaskRunner.runDetached(
           `actor transfer target commit ${actorId}`,
           async () => await operation
         );
-        if (this.options.detachedTaskRunner === undefined) void operation.catch(() => undefined);
         return;
       }
       await operation;
@@ -2714,7 +2907,7 @@ export class DefaultZLinkSpotManager {
                 `Actor '${actor.context.actorId}' has no target ref for deferred Join completion.`
               );
             }
-            await this.options.actorTransferRuntime?.deliverDeferredJoinAccepted(
+            await this.options.actorTransferRuntime?.deliverDeferredJoinCompletion(
               deferredJoinCompletion,
               actor,
               currentRef,
@@ -2749,7 +2942,7 @@ export class DefaultZLinkSpotManager {
             if (failedHandoff !== undefined) {
               throw new Error(
                 `Actor '${actor.context.actorId}' saved handoff packet ` +
-                  `${failedHandoff.index} failed: ${failedHandoff.error ?? 'unknown error'}.`
+                  `${failedHandoff.index} failed: ${diagnosticTextOrAbsent(failedHandoff.error)}.`
               );
             }
             // Spec 15 §4.2 relocation temporary queue: arrivals parked at
@@ -2763,13 +2956,17 @@ export class DefaultZLinkSpotManager {
             // the Session binding aggregate after this boundary.
             this.formalRemoteTransfers.delete(actor.context.actorId);
           }
+          const sealedSession = pendingTransfer?.sealedSession;
           const updateBoundSessionRoute = async (): Promise<void> => {
-            await this.options.actorTransferRuntime?.publishRoutedActorOwnership(actor);
+            await this.options.actorTransferRuntime?.publishRoutedActorOwnership(
+              actor,
+              sealedSession
+            );
             await this.options.actorTransferRuntime?.openRoutedActorSession(actor);
           };
-          // Session routing is an independent post-Ready branch. Callback
-          // sends are retained by the Session owner seal until this converges.
-          if (pendingTransfer !== undefined && this.options.detachedTaskRunner !== undefined) {
+          // Session routing is an independent post-Ready branch. The Session
+          // owner submits current-binding pushes while the route seal remains installed.
+          if (pendingTransfer !== undefined) {
             this.options.detachedTaskRunner.runDetached(
               `actor transfer Session route ${actor.context.actorId}`,
               updateBoundSessionRoute
@@ -2803,13 +3000,10 @@ export class DefaultZLinkSpotManager {
           if (onDetachedTerminal !== undefined) {
             onDetachedTerminal(terminal);
           } else {
-            this.options.detachedTaskRunner?.runDetached(
+            this.options.detachedTaskRunner.runDetached(
               `actor transfer target commit ${actor.context.actorId}`,
               async () => await terminal
             );
-            if (this.options.detachedTaskRunner === undefined) {
-              void terminal.catch(() => undefined);
-            }
           }
           return;
         }
@@ -2876,16 +3070,29 @@ export class DefaultZLinkSpotManager {
     const entrySpotId = this.options.entryNodeRidProvider?.() ?? this.options.entryNodeRid;
     const targetsEntry =
       entrySpotId !== undefined && String(admission.admission.spotId) === String(entrySpotId);
-    if (targetsEntry) {
-      await this.options.dispatchEntryActorJoin?.(meshName, actor, []);
-    } else {
-      const activation = this.activations.resolve(meshName, admission.admission.spotId);
-      if (activation === undefined) {
-        throw new Error(`Actor Join relocation '${relocationId}' target Spot is not active.`);
+    const activation = targetsEntry
+      ? undefined
+      : this.activations.resolve(meshName, admission.admission.spotId);
+    let lifecycleFailure: { readonly error: unknown } | undefined;
+    try {
+      if (targetsEntry) {
+        await this.options.dispatchEntryActorJoin?.(meshName, actor, []);
+      } else {
+        if (activation === undefined) {
+          throw new Error(`Actor Join relocation '${relocationId}' target Spot is not active.`);
+        }
+        await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
       }
-      await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
+    } catch (error) {
+      lifecycleFailure = { error };
+    }
+    if (lifecycleFailure === undefined) {
+      const sourceLeave = submitSourceLeave(admission.admission.actorRef.nodeRid);
+      this.options.detachedTaskRunner.runDetached(
+        `actor Join source leave ${actor.context.actorId}`,
+        () => sourceLeave
+      );
     }
-    await submitSourceLeave(admission.admission.actorRef.nodeRid);
     if (
       outcome.deferredJoinCompletion !== undefined &&
       this.options.actorTransferRuntime !== undefined
@@ -2893,20 +3100,26 @@ export class DefaultZLinkSpotManager {
       const submitMailbox = targetsEntry
         ? <T>(operation: () => Promise<T>): Promise<T> => operation()
         : <T>(operation: () => Promise<T>): Promise<T> => {
-            const activation = this.activations.resolve(meshName, admission.admission.spotId);
             if (activation === undefined) {
               throw new Error(`Actor Join relocation '${relocationId}' target mailbox is missing.`);
             }
             return activation.executeActor(actor.context.actorId, operation);
           };
-      await this.options.actorTransferRuntime.deliverDeferredJoinAccepted(
-        outcome.deferredJoinCompletion,
+      await this.options.actorTransferRuntime.deliverDeferredJoinCompletion(
+        lifecycleFailure === undefined
+          ? outcome.deferredJoinCompletion
+          : {
+              ...outcome.deferredJoinCompletion,
+              status: 'failed',
+              kind: spotActorFailureKind(lifecycleFailure.error)
+            },
         actor,
         actorRef,
         submitMailbox,
         signal
       );
     }
+    if (lifecycleFailure !== undefined) throw lifecycleFailure.error;
     this.formalRemoteActorAdmissions.markCommitted(relocationId, actor);
     return true;
   }
@@ -3142,19 +3355,10 @@ export class DefaultZLinkSpotManager {
   }
 }
 
-function instanceDispatchErrorReason(error: unknown): ZLinkDispatchErrorReason {
-  if (error instanceof ZLinkFrameworkException) {
-    const kind = internalFrameworkErrorKind(error);
-    if (
-      kind === ZLinkFrameworkInternalErrorKind.SpotGenerationStale ||
-      kind === ZLinkFrameworkInternalErrorKind.SpotMoving ||
-      kind === ZLinkFrameworkInternalErrorKind.SpotRouteNotFound ||
-      kind === ZLinkFrameworkInternalErrorKind.RequestTargetNotFound
-    ) {
-      return ZLinkDispatchErrorReason.StaleTarget;
-    }
-  }
-  return ZLinkDispatchErrorReason.HandlerException;
+function spotActorFailureKind(error: unknown): ZLinkFrameworkErrorKind {
+  return error instanceof ZLinkFrameworkException
+    ? error.kind
+    : ZLinkFrameworkErrorKind.InternalFailure;
 }
 
 interface ZLinkFormalRemoteTransferRequest {