feat(input): press --hold <ms> for precise timed key-holds + document timed-driving pattern

Dogfooding by driving a canvas game surfaced that per-action shell round-trips
(keydown; sleep; keyup) are the slowest, lowest-fidelity way to drive anything
timed — each is a process spawn + relay round-trip with ~250ms jitter, so a
'0.8s hold' is anything but.

- 'press <key> --hold <ms>': keyDown, wait, keyUp all inside the daemon, so the
  hold duration is precise and it's one round-trip. For games (hold-to-move/
  charge) and any press-and-hold.
- Documented the real driving pattern in the core skill + --help: script a timed
  sequence in ONE round-trip with 'batch "press d --hold 900" "press j" "wait 200"'
  (batch sends each step to the running daemon; --hold/wait block in-daemon), and
  prefer reading engine state via main-world 'eval' over guessing from pixels.

Parser test covers plain/held/missing-duration. Builds on the keydown/keyup full
descriptor fix.

cli/src/native/actions.rs

@@ -3334,6 +3334,16 @@ async fn handle_press(cmd: &Value, state: &mut DaemonState) -> Result<Value, Str
     // Parse modifier+key chords like "Control+a", "Shift+Enter", "Control+Shift+a"
     let (actual_key, modifiers) = parse_key_chord(key);
 
+    // `--hold <ms>`: keyDown, wait, keyUp — all inside the daemon so the hold
+    // duration is precise (no shell-sleep / round-trip jitter). For games
+    // (hold-to-move/charge) and any press-and-hold interaction.
+    if let Some(ms) = cmd.get("hold").and_then(|v| v.as_u64()) {
+        interaction::dispatch_single_key(&mgr.client, &session_id, &actual_key, "keyDown").await?;
+        tokio::time::sleep(std::time::Duration::from_millis(ms)).await;
+        interaction::dispatch_single_key(&mgr.client, &session_id, &actual_key, "keyUp").await?;
+        return Ok(json!({ "pressed": key, "heldMs": ms }));
+    }
+
     interaction::press_key_with_modifiers(&mgr.client, &session_id, &actual_key, modifiers).await?;
     Ok(json!({ "pressed": key }))
 }