diff --git a/packages/core/src/physics/CharacterController.ts b/packages/core/src/physics/CharacterController.ts
index f3c9e6f048..ea6961b70f 100644
--- a/packages/core/src/physics/CharacterController.ts
+++ b/packages/core/src/physics/CharacterController.ts
@@ -1,5 +1,5 @@
 import { ICharacterController } from "@galacean/engine-design";
-import { Vector3 } from "@galacean/engine-math";
+import { Quaternion, Vector3 } from "@galacean/engine-math";
 import { Engine } from "../Engine";
 import { Entity } from "../Entity";
 import { Collider } from "./Collider";
@@ -162,6 +162,10 @@ export class CharacterController extends Collider {
     (<ICharacterController>this._nativeCollider).setSlopeLimit(this._slopeLimit);
   }
 
+  protected override _teleportToEntityTransform(worldPosition: Vector3, _worldRotation: Quaternion): void {
+    (<ICharacterController>this._nativeCollider).setWorldPosition(worldPosition);
+  }
+
   private _syncWorldPositionFromPhysicalSpace(): void {
     (<ICharacterController>this._nativeCollider).getWorldPosition(this.entity.transform.worldPosition);
   }
diff --git a/packages/core/src/physics/Collider.ts b/packages/core/src/physics/Collider.ts
index a8a591fe56..7e2608f206 100644
--- a/packages/core/src/physics/Collider.ts
+++ b/packages/core/src/physics/Collider.ts
@@ -1,4 +1,5 @@
 import { ICollider, IStaticCollider } from "@galacean/engine-design";
+import { Quaternion, Vector3 } from "@galacean/engine-math";
 import { BoolUpdateFlag } from "../BoolUpdateFlag";
 import { deepClone, ignoreClone } from "../clone/CloneManager";
 import { ICustomClone } from "../clone/ComponentCloner";
@@ -28,6 +29,17 @@ export class Collider extends Component implements ICustomClone {
   protected _shapes: ColliderShape[] = [];
   protected _collisionLayerIndex: number = 0;
 
+  /**
+   * A collider must teleport on the next transform sync when its native actor
+   * already exists at a stale pose, such as after re-entering the scene or after
+   * clone-time native reconstruction. Ordinary first entry can use subclass sync
+   * semantics so kinematic actors still use setKinematicTarget.
+   */
+  @ignoreClone
+  private _pendingReenterTeleport: boolean = false;
+  @ignoreClone
+  private _enteredScene: boolean = false;
+
   /**
    * The shapes of this collider.
    */
@@ -108,15 +120,17 @@ export class Collider extends Component implements ICustomClone {
    * @internal
    */
   _onUpdate(): void {
-    if (this._updateFlag.flag) {
+    const shapes = this._shapes;
+    if (this._pendingReenterTeleport || this._updateFlag.flag) {
       const { transform } = this.entity;
-      (<IStaticCollider>this._nativeCollider).setWorldTransform(
-        transform.worldPosition,
-        transform.worldRotationQuaternion
-      );
+      if (this._pendingReenterTeleport) {
+        this._teleportToEntityTransform(transform.worldPosition, transform.worldRotationQuaternion);
+        this._pendingReenterTeleport = false;
+      } else {
+        this._syncEntityTransformToNative(transform.worldPosition, transform.worldRotationQuaternion);
+      }
 
       const worldScale = transform.lossyWorldScale;
-      const shapes = this._shapes;
       for (let i = 0, n = shapes.length; i < n; i++) {
         shapes[i]._nativeShape?.setWorldScale(worldScale);
       }
@@ -134,6 +148,10 @@ export class Collider extends Component implements ICustomClone {
    */
   override _onEnableInScene(): void {
     this.scene.physics._addCollider(this);
+    if (this._enteredScene) {
+      this._pendingReenterTeleport = true;
+    }
+    this._enteredScene = true;
   }
 
   /**
@@ -148,6 +166,7 @@ export class Collider extends Component implements ICustomClone {
    */
   _cloneTo(target: Collider): void {
     target._syncNative();
+    target._pendingReenterTeleport = true;
   }
 
   /**
@@ -164,6 +183,32 @@ export class Collider extends Component implements ICustomClone {
       this._addNativeShape(this.shapes[i]);
     }
     this._setCollisionLayer();
+    // Teleport native actor to entity's current world pose.
+    // The native actor was created in constructor() with the entity's then-current
+    // worldPosition/Rotation. On clone, the entity's transform fields are deep-cloned
+    // AFTER the Component (and its native actor) are constructed, so the native actor's
+    // pose lags behind the cloned entity transform until this sync.
+    const { transform } = this.entity;
+    this._teleportToEntityTransform(transform.worldPosition, transform.worldRotationQuaternion);
+  }
+
+  /**
+   * Teleport native actor to a world pose (instant, no implied velocity).
+   * Used during initialization paths (clone) where the native actor must be re-aligned
+   * with the entity transform after construction-time pose was based on stale defaults.
+   */
+  protected _teleportToEntityTransform(worldPosition: Vector3, worldRotation: Quaternion): void {
+    (<IStaticCollider>this._nativeCollider).setWorldTransform(worldPosition, worldRotation);
+  }
+
+  /**
+   * Sync entity world transform to native actor for per-frame updates.
+   * Default semantics: teleport (setGlobalPose). Subclasses override to express
+   * physics-aware movement (e.g. DynamicCollider routes kinematic actors through
+   * setKinematicTarget to generate contact events on swept motion).
+   */
+  protected _syncEntityTransformToNative(worldPosition: Vector3, worldRotation: Quaternion): void {
+    (<IStaticCollider>this._nativeCollider).setWorldTransform(worldPosition, worldRotation);
   }
 
   /**
diff --git a/packages/core/src/physics/DynamicCollider.ts b/packages/core/src/physics/DynamicCollider.ts
index 380a3b927f..8cdd9d85f3 100644
--- a/packages/core/src/physics/DynamicCollider.ts
+++ b/packages/core/src/physics/DynamicCollider.ts
@@ -33,6 +33,8 @@ export class DynamicCollider extends Collider {
   private _isKinematic = false;
   private _constraints: DynamicColliderConstraints = 0;
   private _collisionDetectionMode: CollisionDetectionMode = CollisionDetectionMode.Discrete;
+  private _kinematicTransformSyncMode: DynamicColliderKinematicTransformSyncMode =
+    DynamicColliderKinematicTransformSyncMode.Target;
   private _sleepThreshold = 5e-3;
   private _automaticCenterOfMass = true;
   private _automaticInertiaTensor = true;
@@ -325,6 +327,22 @@ export class DynamicCollider extends Collider {
     }
   }
 
+  /**
+   * Controls how entity transform changes are synchronized to a kinematic native actor.
+   *
+   * @remarks
+   * `Target` routes transform changes through {@link move}, so PhysX treats the
+   * actor as moving between frames and can generate swept contacts. `Teleport`
+   * writes the native pose directly and does not imply velocity.
+   */
+  get kinematicTransformSyncMode(): DynamicColliderKinematicTransformSyncMode {
+    return this._kinematicTransformSyncMode;
+  }
+
+  set kinematicTransformSyncMode(value: DynamicColliderKinematicTransformSyncMode) {
+    this._kinematicTransformSyncMode = value;
+  }
+
   /**
    * @internal
    */
@@ -433,6 +451,30 @@ export class DynamicCollider extends Collider {
     super.addShape(shape);
   }
 
+  /**
+   * Route per-frame entity → native transform sync to the correct physics API based
+   * on kinematic state.
+   *
+   * PhysX 4.x docs (PxRigidDynamic):
+   *   "If you intend to move a kinematic actor with [setGlobalPose] and want
+   *    collision detection, use setKinematicTarget() instead."
+   *
+   * setGlobalPose is a teleport: PhysX skips contact detection between the old
+   * and new pose. setKinematicTarget tells PhysX the actor is animating to the
+   * target during the next simulate(), enabling swept contacts. Some compatibility
+   * layers need transform writes to stay teleport-like, so the sync mode is
+   * explicit while {@link move} always keeps target semantics.
+   *
+   * @internal
+   */
+  protected override _syncEntityTransformToNative(worldPosition: Vector3, worldRotation: Quaternion): void {
+    if (this._isKinematic && this._kinematicTransformSyncMode === DynamicColliderKinematicTransformSyncMode.Target) {
+      (<IDynamicCollider>this._nativeCollider).move(worldPosition, worldRotation);
+    } else {
+      super._syncEntityTransformToNative(worldPosition, worldRotation);
+    }
+  }
+
   /**
    * @internal
    */
@@ -460,6 +502,7 @@ export class DynamicCollider extends Collider {
     target._angularVelocity.copyFrom(this.angularVelocity);
     target._centerOfMass.copyFrom(this.centerOfMass);
     target._inertiaTensor.copyFrom(this.inertiaTensor);
+    target._kinematicTransformSyncMode = this._kinematicTransformSyncMode;
     super._cloneTo(target);
   }
 
@@ -555,6 +598,16 @@ export enum CollisionDetectionMode {
   ContinuousSpeculative
 }
 
+/**
+ * Kinematic transform synchronization mode.
+ */
+export enum DynamicColliderKinematicTransformSyncMode {
+  /** Synchronize transform changes through PhysX setKinematicTarget. */
+  Target,
+  /** Synchronize transform changes by directly teleporting the native actor. */
+  Teleport
+}
+
 /**
  * Use these flags to constrain motion of dynamic collider.
  */
diff --git a/packages/core/src/physics/index.ts b/packages/core/src/physics/index.ts
index 537bd367d6..f2d4cdf576 100644
--- a/packages/core/src/physics/index.ts
+++ b/packages/core/src/physics/index.ts
@@ -1,6 +1,11 @@
 export { CharacterController } from "./CharacterController";
 export { Collider } from "./Collider";
-export { CollisionDetectionMode, DynamicCollider, DynamicColliderConstraints } from "./DynamicCollider";
+export {
+  CollisionDetectionMode,
+  DynamicCollider,
+  DynamicColliderConstraints,
+  DynamicColliderKinematicTransformSyncMode
+} from "./DynamicCollider";
 export { HitResult } from "./HitResult";
 export { PhysicsMaterial } from "./PhysicsMaterial";
 export { PhysicsScene } from "./PhysicsScene";
diff --git a/packages/physics-lite/src/LiteDynamicCollider.ts b/packages/physics-lite/src/LiteDynamicCollider.ts
index dae27bf3ab..11b90bed01 100644
--- a/packages/physics-lite/src/LiteDynamicCollider.ts
+++ b/packages/physics-lite/src/LiteDynamicCollider.ts
@@ -60,7 +60,13 @@ export class LiteDynamicCollider extends LiteCollider implements IDynamicCollide
    * {@inheritDoc IDynamicCollider.move }
    */
   move(positionOrRotation: Vector3 | Quaternion, rotation?: Quaternion): void {
-    throw "Physics-lite don't support move. Use Physics-PhysX instead!";
+    if (rotation) {
+      this.setWorldTransform(positionOrRotation as Vector3, rotation);
+    } else if (positionOrRotation instanceof Vector3) {
+      this.setWorldTransform(positionOrRotation, this._transform.rotationQuaternion);
+    } else {
+      this.setWorldTransform(this._transform.position, positionOrRotation);
+    }
   }
 
   /**
diff --git a/packages/physics-physx/src/PhysXDynamicCollider.ts b/packages/physics-physx/src/PhysXDynamicCollider.ts
index 31510ae2de..71679e1932 100644
--- a/packages/physics-physx/src/PhysXDynamicCollider.ts
+++ b/packages/physics-physx/src/PhysXDynamicCollider.ts
@@ -24,6 +24,20 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
   private static _tempTranslation = new Vector3();
   private static _tempRotation = new Quaternion();
 
+  /**
+   * Whether actor is currently kinematic.
+   * PhysX 拒绝在 kinematic actor 上启用 CCD（会打印警告并忽略），
+   * 所以 setCollisionDetectionMode 在 kinematic 状态下只缓存目标值，
+   * 等切回 dynamic 时再真正写到 PhysX。
+   */
+  private _isKinematic: boolean = false;
+
+  /**
+   * Cached collision detection mode. Always reflects user's intent.
+   * 实际 PhysX CCD flag 可能跟这个不一致（kinematic 时强制 Discrete）。
+   */
+  private _collisionDetectionMode: number = CollisionDetectionMode.Discrete;
+
   constructor(physXPhysics: PhysXPhysics, position: Vector3, rotation: Quaternion) {
     super(physXPhysics);
     const transform = this._transform(position, rotation);
@@ -143,7 +157,7 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
 
   /**
    * {@inheritDoc IDynamicCollider.setSleepThreshold }
-   * @default 1e-5f * PxTolerancesScale::speed * PxTolerancesScale::speed
+   * @default 5e-5f * PxTolerancesScale::speed * PxTolerancesScale::speed
    */
   setSleepThreshold(value: number): void {
     this._pxActor.setSleepThreshold(value);
@@ -158,10 +172,52 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
 
   /**
    * {@inheritDoc IDynamicCollider.setCollisionDetectionMode }
+   *
+   * PhysX 在 kinematic actor 上调用 setRigidBodyFlag(eENABLE_CCD, true) 会触发警告:
+   *   "kinematic bodies with CCD enabled are not supported! CCD will be ignored"
+   * 虽然 PhysX 会忽略这次调用而非真的拒绝（切回 dynamic 时 flag 不会自动恢复），
+   * 但每次 setIsKinematic 切换都会让这个 warning 重复打印，污染日志，
+   * 同时让 actor 在 dynamic 状态下 CCD flag 状态不确定。
+   *
+   * 解决: 只在 dynamic 状态时立即 apply CCD flags。kinematic 时仅缓存到
+   * `_collisionDetectionMode`，等切回 dynamic 时由 setIsKinematic 重新 apply。
    */
   setCollisionDetectionMode(value: number): void {
+    this._collisionDetectionMode = value;
+    if (!this._isKinematic) {
+      this._applyCollisionDetectionFlags(value);
+    }
+  }
+
+  /**
+   * {@inheritDoc IDynamicCollider.setUseGravity }
+   */
+  setUseGravity(value: boolean): void {
+    this._pxActor.setActorFlag(this._physXPhysics._physX.PxActorFlag.eDISABLE_GRAVITY, !value);
+  }
+
+  /**
+   * {@inheritDoc IDynamicCollider.setIsKinematic }
+   *
+   * 切换 kinematic 状态时同步处理 CCD flag：
+   *   - 切到 kinematic 前先关 CCD（避免 PhysX 警告 + 让状态显式）
+   *   - 切回 dynamic 后恢复用户期望的 CCD mode（来自 `_collisionDetectionMode` 缓存）
+   */
+  setIsKinematic(value: boolean): void {
+    if (this._isKinematic === value) return;
     const physX = this._physXPhysics._physX;
+    if (value) {
+      this._applyCollisionDetectionFlags(CollisionDetectionMode.Discrete);
+      this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eKINEMATIC, true);
+    } else {
+      this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eKINEMATIC, false);
+      this._applyCollisionDetectionFlags(this._collisionDetectionMode);
+    }
+    this._isKinematic = value;
+  }
 
+  private _applyCollisionDetectionFlags(value: number): void {
+    const physX = this._physXPhysics._physX;
     switch (value) {
       case CollisionDetectionMode.Continuous:
         this._pxActor.setRigidBodyFlag(physX.PxRigidBodyFlag.eENABLE_CCD, true);
@@ -186,24 +242,6 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
     }
   }
 
-  /**
-   * {@inheritDoc IDynamicCollider.setUseGravity }
-   */
-  setUseGravity(value: boolean): void {
-    this._pxActor.setActorFlag(this._physXPhysics._physX.PxActorFlag.eDISABLE_GRAVITY, !value);
-  }
-
-  /**
-   * {@inheritDoc IDynamicCollider.setIsKinematic }
-   */
-  setIsKinematic(value: boolean): void {
-    if (value) {
-      this._pxActor.setRigidBodyFlag(this._physXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, true);
-    } else {
-      this._pxActor.setRigidBodyFlag(this._physXPhysics._physX.PxRigidBodyFlag.eKINEMATIC, false);
-    }
-  }
-
   /**
    * {@inheritDoc IDynamicCollider.setConstraints }
    */
@@ -213,34 +251,52 @@ export class PhysXDynamicCollider extends PhysXCollider implements IDynamicColli
 
   /**
    * {@inheritDoc IDynamicCollider.addForce }
+   *
+   * PhysX 在 kinematic actor 上调 addForce 是 no-op（doc: "kinematic bodies don't
+   * respond to forces"）。提前 return 避免无意义的 wasm boundary cross。
+   *
+   * Sleeping actor 不需要显式 wakeUp — wasm binding 调用 `addForce(force, eFORCE,
+   * autowake=true)`，PhysX 自动唤醒（已通过 `applyForce on sleeping actor` 测试验证）。
    */
   addForce(force: Vector3) {
+    if (this._isKinematic) return;
     this._pxActor.addForce({ x: force.x, y: force.y, z: force.z });
   }
 
   /**
    * {@inheritDoc IDynamicCollider.addTorque }
+   *
+   * 同 addForce — kinematic 提前 return，sleeping 由 PhysX autowake 自动处理。
    */
   addTorque(torque: Vector3) {
+    if (this._isKinematic) return;
     this._pxActor.addTorque({ x: torque.x, y: torque.y, z: torque.z });
   }
 
   /**
    * {@inheritDoc IDynamicCollider.move }
+   *
+   * PhysX 要求 setKinematicTarget 的 rotation 是 normalized quaternion，否则会触发
+   * 内部 assertion / 警告，并把 actor 转到错误的姿态。所以在写入 wasm 边界前统一 normalize。
    */
   move(positionOrRotation: Vector3 | Quaternion, rotation?: Quaternion): void {
+    const tempTranslation = PhysXDynamicCollider._tempTranslation;
+    const tempRotation = PhysXDynamicCollider._tempRotation;
+
     if (rotation) {
-      this._pxActor.setKinematicTarget(positionOrRotation, rotation);
+      tempRotation.copyFrom(rotation).normalize();
+      this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
       return;
     }
 
-    const tempTranslation = PhysXDynamicCollider._tempTranslation;
-    const tempRotation = PhysXDynamicCollider._tempRotation;
-    this.getWorldTransform(tempTranslation, tempRotation);
     if (positionOrRotation instanceof Vector3) {
+      this.getWorldTransform(tempTranslation, tempRotation);
+      // current rotation read from PhysX is already normalized; no extra work needed
       this._pxActor.setKinematicTarget(positionOrRotation, tempRotation);
     } else {
-      this._pxActor.setKinematicTarget(tempTranslation, positionOrRotation);
+      this.getWorldTransform(tempTranslation, tempRotation);
+      tempRotation.copyFrom(positionOrRotation).normalize();
+      this._pxActor.setKinematicTarget(tempTranslation, tempRotation);
     }
   }
 
diff --git a/tests/src/core/physics/Collider.test.ts b/tests/src/core/physics/Collider.test.ts
index 4a610d6484..688b5a6767 100644
--- a/tests/src/core/physics/Collider.test.ts
+++ b/tests/src/core/physics/Collider.test.ts
@@ -12,7 +12,7 @@ import {
 import { Vector3 } from "@galacean/engine-math";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { LitePhysics } from "@galacean/engine-physics-lite";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { vi, describe, beforeAll, beforeEach, expect, it, afterEach } from "vitest";
 
 class CollisionScript extends Script {
@@ -477,6 +477,19 @@ describe("Collider Layer Collision Tests", () => {
       engine.sceneManager.activeScene.physics.setColliderLayerCollision(Layer.Layer10, Layer.Layer2, true);
     });
 
+    it("syncs kinematic transform changes as teleport in LitePhysics", () => {
+      const entity = rootEntity.createChild("kinematic");
+      const collider = entity.addComponent(DynamicCollider);
+      collider.addShape(new BoxColliderShape());
+      collider.isKinematic = true;
+
+      entity.transform.setPosition(2, 0, 0);
+
+      // @ts-ignore
+      expect(() => engine.sceneManager.activeScene.physics._update(1 / 60)).not.toThrow();
+      expect(entity.transform.position.x).toBe(2);
+    });
+
     afterEach(() => {
       const entities = rootEntity.children;
       for (let i = entities.length - 1; i >= 0; i--) {
diff --git a/tests/src/core/physics/Collision.test.ts b/tests/src/core/physics/Collision.test.ts
index 8fc27ef8b9..812821639c 100644
--- a/tests/src/core/physics/Collision.test.ts
+++ b/tests/src/core/physics/Collision.test.ts
@@ -1,4 +1,13 @@
-import { BoxColliderShape, DynamicCollider, Entity, Engine, Script, StaticCollider } from "@galacean/engine-core";
+import {
+  BoxColliderShape,
+  DynamicCollider,
+  DynamicColliderConstraints,
+  Entity,
+  Engine,
+  Script,
+  SphereColliderShape,
+  StaticCollider
+} from "@galacean/engine-core";
 import { Vector3 } from "@galacean/engine-math";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { WebGLEngine } from "@galacean/engine-rhi-webgl";
@@ -22,6 +31,20 @@ describe("Collision", function () {
     return boxEntity;
   }
 
+  function addSphere(radius: number, pos: Vector3) {
+    const sphereEntity = rootEntity.createChild("SphereEntity");
+    sphereEntity.transform.setPosition(pos.x, pos.y, pos.z);
+
+    const sphereShape = new SphereColliderShape();
+    sphereShape.material.dynamicFriction = 0;
+    sphereShape.material.staticFriction = 0;
+    sphereShape.radius = radius;
+    const sphereCollider = sphereEntity.addComponent(DynamicCollider);
+    sphereCollider.addShape(sphereShape);
+    sphereCollider.useGravity = false;
+    return sphereEntity;
+  }
+
   function formatValue(value: number) {
     return Math.round(value * 100000) / 100000;
   }
@@ -190,4 +213,191 @@ describe("Collision", function () {
       engine.sceneManager.activeScene.physics._update(1);
     });
   });
+
+  it("reports billiard hitBall sphere normal from kinematic other to dynamic target self", function () {
+    engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+    const targetBall = addSphere(0.5, new Vector3(0, 0, 0));
+    const hitBall = addSphere(0.5, new Vector3(-3, 0, 0));
+    const hitCollider = hitBall.getComponent(DynamicCollider);
+    hitCollider.isKinematic = true;
+
+    return new Promise<void>((done) => {
+      targetBall.addComponent(
+        class extends Script {
+          onCollisionEnter(other: Collision): void {
+            expect(other.shape).toBe(hitCollider.shapes[0]);
+            const contacts = [];
+            other.getContacts(contacts);
+            expect(contacts.length).toBeGreaterThan(0);
+
+            const contactNormal = contacts[0].normal;
+            expect(formatValue(contactNormal.x)).toBe(1);
+            expect(formatValue(contactNormal.y)).toBe(0);
+            expect(formatValue(contactNormal.z)).toBe(0);
+
+            const hitToTarget = new Vector3();
+            Vector3.subtract(targetBall.transform.worldPosition, hitBall.transform.worldPosition, hitToTarget);
+            hitToTarget.normalize();
+            expect(formatValue(Vector3.dot(contactNormal, hitToTarget))).toBe(1);
+
+            const scaledNormal = new Vector3();
+            Vector3.scale(contactNormal, 2 * Vector3.dot(hitToTarget, contactNormal), scaledNormal);
+            const reflected = new Vector3();
+            Vector3.subtract(hitToTarget, scaledNormal, reflected);
+            reflected.normalize();
+            expect(formatValue(reflected.x)).toBe(-1);
+
+            done();
+          }
+        }
+      );
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      hitCollider.move(new Vector3(-0.9, 0, 0));
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+    });
+  });
+
+  function probeKinematicCallback(opts: {
+    aKine: boolean;
+    bKine: boolean;
+    timeoutMs?: number;
+  }): Promise<{ fired: boolean }> {
+    return new Promise((resolve) => {
+      engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+      const boxA = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+      const boxB = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(3, 0, 0));
+      const colA = boxA.getComponent(DynamicCollider);
+      const colB = boxB.getComponent(DynamicCollider);
+      colA.useGravity = false;
+      colB.useGravity = false;
+      colA.isKinematic = opts.aKine;
+      colB.isKinematic = opts.bKine;
+
+      let fired = false;
+      boxA.addComponent(
+        class extends Script {
+          onCollisionEnter(_other: Collision): void {
+            fired = true;
+            resolve({ fired: true });
+          }
+        }
+      );
+
+      // Step a few frames to let PhysX settle initial state.
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // Teleport B onto A → expect onCollisionEnter.
+      boxB.transform.setPosition(-3, 0, 0);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      if (!fired) resolve({ fired: false });
+    });
+  }
+
+  it("kinematic-kinematic overlap via transform.setPosition fires onCollisionEnter", async function () {
+    const r = await probeKinematicCallback({ aKine: true, bKine: true });
+    expect(r.fired).toBe(true);
+  });
+
+  it("kinematic-dynamic overlap via transform.setPosition fires onCollisionEnter", async function () {
+    const r = await probeKinematicCallback({ aKine: true, bKine: false });
+    expect(r.fired).toBe(true);
+  });
+
+  it("dynamic-dynamic overlap via transform.setPosition fires onCollisionEnter", async function () {
+    const r = await probeKinematicCallback({ aKine: false, bKine: false });
+    expect(r.fired).toBe(true);
+  });
+
+  it("kinematic-kinematic overlap via move fires onCollisionEnter", function () {
+    return new Promise<void>((resolve, reject) => {
+      engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+      const boxA = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+      const boxB = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(3, 0, 0));
+      const colA = boxA.getComponent(DynamicCollider);
+      const colB = boxB.getComponent(DynamicCollider);
+      colA.useGravity = false;
+      colB.useGravity = false;
+      colA.isKinematic = true;
+      colB.isKinematic = true;
+
+      let fired = false;
+      boxA.addComponent(
+        class extends Script {
+          onCollisionEnter(_other: Collision): void {
+            fired = true;
+            resolve();
+          }
+        }
+      );
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // Move B onto A via DynamicCollider.move() — this internally calls setKinematicTarget.
+      colB.move(new Vector3(-3, 0, 0));
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      if (!fired) reject(new Error("kine-kine setKinematicTarget did NOT fire onCollisionEnter"));
+    });
+  });
+
+  it("fully constrained dynamic overlap via transform.setPosition fires onCollisionEnter", function () {
+    return new Promise<void>((resolve) => {
+      engine.sceneManager.activeScene.physics.gravity = new Vector3(0, 0, 0);
+      const boxA = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(-3, 0, 0));
+      const boxB = addBox(new Vector3(1, 1, 1), DynamicCollider, new Vector3(3, 0, 0));
+      const colA = boxA.getComponent(DynamicCollider);
+      const colB = boxB.getComponent(DynamicCollider);
+      const FREEZE_ALL =
+        DynamicColliderConstraints.FreezePositionX |
+        DynamicColliderConstraints.FreezePositionY |
+        DynamicColliderConstraints.FreezePositionZ |
+        DynamicColliderConstraints.FreezeRotationX |
+        DynamicColliderConstraints.FreezeRotationY |
+        DynamicColliderConstraints.FreezeRotationZ;
+      colA.constraints = FREEZE_ALL;
+      colB.constraints = FREEZE_ALL;
+      colA.useGravity = false;
+      colB.useGravity = false;
+      colA.isKinematic = false;
+      colB.isKinematic = false;
+
+      let fired = false;
+      boxA.addComponent(
+        class extends Script {
+          onCollisionEnter(_other: Collision): void {
+            fired = true;
+            resolve();
+          }
+        }
+      );
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      boxB.transform.setPosition(-3, 0, 0);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      if (!fired) {
+        expect.fail("expected onCollisionEnter to fire for dynamic-frozen pair after teleport");
+      }
+    });
+  });
 });
diff --git a/tests/src/core/physics/DynamicCollider.test.ts b/tests/src/core/physics/DynamicCollider.test.ts
index ecde06ef3d..abe08aaa09 100644
--- a/tests/src/core/physics/DynamicCollider.test.ts
+++ b/tests/src/core/physics/DynamicCollider.test.ts
@@ -6,10 +6,11 @@ import {
   DynamicCollider,
   DynamicColliderConstraints,
   CollisionDetectionMode,
+  DynamicColliderKinematicTransformSyncMode,
   StaticCollider,
   PlaneColliderShape
 } from "@galacean/engine-core";
-import { WebGLEngine } from "@galacean/engine";
+import { WebGLEngine } from "@galacean/engine-rhi-webgl";
 import { PhysXPhysics } from "@galacean/engine-physics-physx";
 import { Vector3 } from "@galacean/engine-math";
 import { vi, describe, beforeAll, beforeEach, expect, it } from "vitest";
@@ -278,6 +279,80 @@ describe("DynamicCollider", function () {
     expect(formatValue(boxCollider.inertiaTensor.y)).eq(1);
   });
 
+  it("applyForce on sleeping actor must wake up and apply force", function () {
+    // Validates whether PhysX wasm `addForce(force, eFORCE, autowake=true)` actually wakes a
+    // sleeping actor on its own — or whether the engine's explicit wakeUp() call is required.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    boxCollider.linearDamping = 0;
+
+    boxCollider.sleep();
+    expect(boxCollider.isSleeping()).toBe(true);
+
+    boxCollider.applyForce(new Vector3(1, 0, 0));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+
+    expect(formatValue(boxCollider.linearVelocity.x)).eq(0.01667);
+    expect(boxCollider.isSleeping()).toBe(false);
+  });
+
+  it("applyForce after kinematic→dynamic switch (mimic billiards game break flow)", function () {
+    // Game pattern: all balls set kinematic at init, switched back to dynamic on break,
+    // then applyForce. Verifies the original 'force lost' bug was actually from this path.
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.mass = 1;
+    boxCollider.useGravity = false;
+    boxCollider.linearDamping = 0;
+
+    boxCollider.isKinematic = true;
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+    boxCollider.isKinematic = false;
+
+    boxCollider.applyForce(new Vector3(1, 0, 0));
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+
+    expect(formatValue(boxCollider.linearVelocity.x)).eq(0.01667);
+  });
+
+  it("applyForce is consumed by the first fixed substep in a frame", function () {
+    const scene = engine.sceneManager.activeScene;
+    const originalFTS = scene.physics.fixedTimeStep;
+    let dv_1_60 = 0;
+    let dv_1_480 = 0;
+
+    try {
+      const probe = (fts: number) => {
+        rootEntity.clearChildren();
+        scene.physics.fixedTimeStep = fts;
+        const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+        const c = box.getComponent(DynamicCollider);
+        c.mass = 1;
+        c.useGravity = false;
+        c.linearDamping = 0;
+        c.angularDamping = 0;
+        c.applyForce(new Vector3(100, 0, 0));
+        // @ts-ignore
+        scene.physics._update(1 / 60);
+        return c.linearVelocity.x;
+      };
+
+      dv_1_60 = probe(1 / 60);
+      dv_1_480 = probe(1 / 480);
+    } finally {
+      scene.physics.fixedTimeStep = originalFTS;
+    }
+
+    expect(dv_1_60).toBeCloseTo(100 / 60, 2);
+    expect(dv_1_480).toBeCloseTo(100 / 480, 2);
+    expect(dv_1_60 / dv_1_480).toBeCloseTo(8, 1);
+  });
+
   it("maxAngularVelocity", function () {
     const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
     const boxCollider = box.getComponent(DynamicCollider);
@@ -398,6 +473,48 @@ describe("DynamicCollider", function () {
     expect(box.transform.position.y).below(1);
   });
 
+  it("teleports kinematic target collider on re-enable instead of sweeping from stale native pose", function () {
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(-10, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    boxCollider.useGravity = false;
+    boxCollider.isKinematic = true;
+    boxCollider.kinematicTransformSyncMode = DynamicColliderKinematicTransformSyncMode.Target;
+
+    // @ts-ignore
+    engine.sceneManager.activeScene.physics._update(1 / 60);
+
+    // @ts-ignore - intentionally observe the native boundary used by Collider sync.
+    const nativeCollider = boxCollider._nativeCollider;
+    const originalMove = nativeCollider.move.bind(nativeCollider);
+    const originalSetWorldTransform = nativeCollider.setWorldTransform.bind(nativeCollider);
+    let moveCalls = 0;
+    let setWorldTransformCalls = 0;
+    nativeCollider.move = (...args: Parameters<typeof nativeCollider.move>) => {
+      moveCalls++;
+      return originalMove(...args);
+    };
+    nativeCollider.setWorldTransform = (...args: Parameters<typeof nativeCollider.setWorldTransform>) => {
+      setWorldTransformCalls++;
+      return originalSetWorldTransform(...args);
+    };
+
+    try {
+      box.isActive = false;
+      box.transform.setPosition(10, 0, 0);
+      box.isActive = true;
+
+      // @ts-ignore
+      engine.sceneManager.activeScene.physics._update(1 / 60);
+
+      expect(moveCalls).eq(0);
+      expect(setWorldTransformCalls).eq(1);
+      expect(formatValue(box.transform.position.x)).eq(10);
+    } finally {
+      nativeCollider.move = originalMove;
+      nativeCollider.setWorldTransform = originalSetWorldTransform;
+    }
+  });
+
   it("constraints", function () {
     const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
     const boxCollider = box.getComponent(DynamicCollider);
@@ -442,6 +559,46 @@ describe("DynamicCollider", function () {
     ).toBeTruthy();
   });
 
+  it("CCD mode survives kinematic toggle", function () {
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    // @ts-ignore
+    const physX = boxCollider._nativeCollider._physXPhysics._physX;
+    const ccdFlag = () =>
+      // @ts-ignore
+      boxCollider._nativeCollider._pxActor.getRigidBodyFlags(physX.PxRigidBodyFlag.eENABLE_CCD);
+
+    boxCollider.collisionDetectionMode = CollisionDetectionMode.Continuous;
+    expect(ccdFlag()).toBeTruthy();
+
+    boxCollider.isKinematic = true;
+    expect(ccdFlag()).toBeFalsy();
+
+    boxCollider.isKinematic = false;
+    expect(ccdFlag()).toBeTruthy();
+    expect(boxCollider.collisionDetectionMode).toEqual(CollisionDetectionMode.Continuous);
+  });
+
+  it("setCollisionDetectionMode in kinematic state defers native CCD flag application", function () {
+    const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
+    const boxCollider = box.getComponent(DynamicCollider);
+    // @ts-ignore
+    const physX = boxCollider._nativeCollider._physXPhysics._physX;
+    const ccdFlag = () =>
+      // @ts-ignore
+      boxCollider._nativeCollider._pxActor.getRigidBodyFlags(physX.PxRigidBodyFlag.eENABLE_CCD);
+
+    boxCollider.isKinematic = true;
+    expect(ccdFlag()).toBeFalsy();
+
+    boxCollider.collisionDetectionMode = CollisionDetectionMode.Continuous;
+    expect(ccdFlag()).toBeFalsy();
+    expect(boxCollider.collisionDetectionMode).toEqual(CollisionDetectionMode.Continuous);
+
+    boxCollider.isKinematic = false;
+    expect(ccdFlag()).toBeTruthy();
+  });
+
   it("sleep", function () {
     const box = addBox(new Vector3(2, 2, 2), DynamicCollider, new Vector3(0, 0, 0));
     const boxCollider = box.getComponent(DynamicCollider);
diff --git a/tests/src/core/physics/PhysicsScene.test.ts b/tests/src/core/physics/PhysicsScene.test.ts
index dd84c2d5f9..6a3d21a297 100644
--- a/tests/src/core/physics/PhysicsScene.test.ts
+++ b/tests/src/core/physics/PhysicsScene.test.ts
@@ -1893,15 +1893,16 @@ describe("Physics Test", () => {
         const collisionTestScript = entity1.addComponent(CollisionTestScript);
         collisionTestScript.useLite = false;
 
-        // Test that collision works correctly, A is dynamic and kinematic, B is static.
+        // SceneDesc.staticKineFilteringMode = eKEEP + Collider.move() routing kinematic
+        // to setKinematicTarget make static-kinematic pairs generate contact events.
         resetSpy();
         setColliderProps(entity1, true, false, true);
         setColliderProps(entity2, false, false, false);
         updatePhysics(physicsMgr);
 
-        expect(collisionTestScript.onCollisionEnter).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionStay).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionExit).not.toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionEnter).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionStay).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionExit).toHaveBeenCalled();
         expect(collisionTestScript.onTriggerEnter).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerStay).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerExit).not.toHaveBeenCalled();
@@ -2013,15 +2014,16 @@ describe("Physics Test", () => {
         const collisionTestScript = entity1.addComponent(CollisionTestScript);
         collisionTestScript.useLite = false;
 
-        // Test that collision works correctly, both A,B are dynamic, kinematic.
+        // SceneDesc.kineKineFilteringMode = eKEEP + Collider.move() routing kinematic
+        // to setKinematicTarget make kine-kine pairs generate contact events.
         resetSpy();
         setColliderProps(entity1, true, false, true);
         setColliderProps(entity2, true, false, true);
         updatePhysics(physicsMgr);
 
-        expect(collisionTestScript.onCollisionEnter).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionStay).not.toHaveBeenCalled();
-        expect(collisionTestScript.onCollisionExit).not.toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionEnter).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionStay).toHaveBeenCalled();
+        expect(collisionTestScript.onCollisionExit).toHaveBeenCalled();
         expect(collisionTestScript.onTriggerEnter).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerStay).not.toHaveBeenCalled();
         expect(collisionTestScript.onTriggerExit).not.toHaveBeenCalled();