Exactly.
1 second would be chosen just because it can be noticed with non trivial amount of wall clocks and watches.
But even for 1 second, it would not be possible with OS alone on heavy load. Would also affected by the design of the apps the user want to react in time.
But even if all apps installed are well designed, if underlyingy OS does not properly support realtime (for human) interactivity, reactions should be delayed too much.
There are things that you can do to give an
illusion of responsiveness. E.g., have the driver generate keyclicks each time a keystroke is processed -- even if the application layer hasn't seen them. The risk, there, is that the user can get ahead of the application and has no way to undo the keystrokes he may have accidentally "typed ahead".
[IBM had an OS that dynamically split the screen so what you had typed-ahead was visible in the lower half of the screen (text console). This is somewhat handled in a shell but not as prettily]
For example, Windows apps throw up a splash screen before the binary has completely loaded. Then, typically adorn that with "progress messages" to reassure the user that the system hasn't "hung" (especially valuable if the user can't hear the disk activity as all of the DLLs are pulled into play).
In an appliance that I'm currently developing, I deliberately load each application ("object server") in two pieces; the first is responsible for setting up the environment for the service while the second actually provides the service. This lets the service announce itself (to other clients) before it is actually ready for requests AND lets the resources that were used in setting it up to be freed/discarded once that phase is complete.
Traditionally, interactive tasks were given enhanced priority (for an initial short time) in the hope that this would enhance responsiveness. If a task ran for longer, then its priority would diminish.
But, you also have to worry about how applications can
exploit this to the detriment of other applications (e.g., keep exec()ing bits of yourself as new processes so THEY continue to run at elevated priority as YOURS diminishes)