@@ -20,7 +20,7 @@ members = [
 ]
 
 [workspace.package]
-version = "2.0.0-alpha.5"
+version = "2.0.0-alpha.6"
 edition = "2024"
 rust-version = "1.96"
 publish = false
@@ -50,8 +50,8 @@ windhawk-core-client = { path = "core-client" }
 windhawk-core-host = { path = "core-host" }
 # The runtime-broker transport: a length-prefixed JSON channel over a duplex
 # named pipe, with the unprivileged end as the pipe server and the privileged one
-# as the pipe client. Outside the core layering, like the bridge and the referee:
-# no core crate at all, and nothing Windhawk-specific - it is generic over the
+# as the pipe client. Outside the core layering, like the bridge: no core crate
+# at all, and nothing Windhawk-specific - it is generic over the
 # request/response/push types so it is testable over an in-process pipe pair.
 windhawk-broker = { path = "broker" }
 
@@ -84,7 +84,7 @@ thiserror = "2.0"
 # (matching js-yaml, the TS implementation we replace), where saphyr silently
 # keeps the last value. default-features off drops the `encoding` feature
 # (encoding_rs); the core feeds the parser &str it decoded itself.
-yaml-rust2 = { version = "0.11", default-features = false }
+yaml-rust2 = { version = "0.13", default-features = false }
 # Raw Win32 bindings for the adapter and ffi crates. Pinned to the version the
 # rest of the tree already resolves to, so the workspace edge adds no version of
 # its own; the Tauri UI and the embed-resource build chain still pull 0.59/0.60,
@@ -125,36 +125,41 @@ embed-resource = "3"
 # bridges the webview envelope protocol to core C-ABI invokes. windhawk-ui is
 # x64/ARM64 only, so it is excluded from the i686 build; the i686 production
 # core stays for the Electron extension. tauri-build is the build-script half
-# (codegen + ACL).
-tauri = { version = "2", features = [] }
-tauri-build = { version = "2", features = [] }
+# (codegen + ACL). tauri-runtime-wry is the webview runtime the app selects on
+# the builder, and the home of the wry extension traits shell.rs reaches the
+# WebView2 controller through. Tauri 3 is on its alpha line; it is what carries
+# tao 0.37 and wry 0.57, which the UI's window handling is written against.
+tauri = { version = "3.0.0-alpha.2", features = [] }
+tauri-build = { version = "3.0.0-alpha.1", features = [] }
+tauri-runtime-wry = { version = "3.0.0-alpha.2", features = [] }
 # The launcher contract + external-link shim: single-instance makes a bare
 # re-launch ensure-running-and-foreground (and `--quit` ask the running instance
 # to exit); opener routes the front-end's external links to the system browser.
-# Both are ui-crate-only, tracking tauri 2.
-tauri-plugin-single-instance = { version = "2", features = [] }
-tauri-plugin-opener = { version = "2", features = [] }
+# Both are ui-crate-only, tracking tauri 3.
+tauri-plugin-single-instance = { version = "3.0.0-alpha.1", features = [] }
+tauri-plugin-opener = { version = "3.0.0-alpha.1", features = [] }
 # The WebView2 COM bindings + safe event-handler wrappers. ui-crate-only; pinned
 # to the version already in the tauri transitive tree (no duplicate, no new
 # license/advisory). Used in shell.rs to disable a few browser shortcuts (print,
 # reload, hard reload, caret browsing) via the controller's
 # AcceleratorKeyPressed event, and to trim the context menu to back/forward plus
 # the input clipboard items via its ContextMenuRequested event, both reached
 # through Tauri's `with_webview`.
-webview2-com = "0.38"
+webview2-com = "0.39"
 # The windows-rs COM core (the `Interface` trait + `PWSTR`), needed by shell.rs to
 # QueryInterface the WebView2 controller's core object up to ICoreWebView2_11 (which
 # carries ContextMenuRequested) and to read each menu item's name. ui-crate-only; pinned
-# to "0.61", the exact version webview2-com already pulls (windows-core 0.61.2), so the
+# to "0.62", the exact version webview2-com, wry, and tao already pull, so the
 # `Interface` impls on the ICoreWebView2* types match and no new version/duplicate enters
 # the tree.
-windows-core = "0.61"
+windows-core = "0.62"
 # The ergonomic windows-rs bindings (RAII COM wrappers), used by the UI's native file
 # dialog (ui/src/file_dialog.rs: IFileOpenDialog/IFileSaveDialog for user-data
-# export/import). ui-crate-only; pinned to "0.61", the exact version webview2-com already
-# pulls (windows 0.61.3), so it adds no new crate/version to the tree. Features are
-# enabled on the consuming crate.
-windows = "0.61"
+# export/import). ui-crate-only; pinned to "0.62", the exact version webview2-com, wry,
+# and tao already pull, so it adds no new crate/version to the tree (tauri-plugin-opener
+# still pulls a 0.61 beside it, a duplicate cargo-deny warns on). Features are enabled
+# on the consuming crate.
+windows = "0.62"
 # The `log` facade, which the Tauri/wry window stack reports through. It reports a
 # window or webview that fails to build there and then DISCARDS it - the build
 # answers Ok regardless - so the UI installs a small capture of the last few
 
@@ -6,12 +6,12 @@ edition.workspace = true
 rust-version.workspace = true
 publish.workspace = true
 
-# Outside the core layering, like the bridge and the referee: no core crate at
-# all. This is a transport and nothing else - it is generic over the request,
-# response, and push types and knows no Windhawk command, which is what makes it
-# testable over an in-process pipe pair with a fake handler. serde/serde_json
-# encode and decode the caller's frame types; windows-sys is the named pipe, the
-# overlapped I/O, the security descriptor, and the peer token/process queries.
+# Outside the core layering, like the bridge: no core crate at all. This is a
+# transport and nothing else - it is generic over the request, response, and
+# push types and knows no Windhawk command, which is what makes it testable over
+# an in-process pipe pair with a fake handler. serde/serde_json encode and
+# decode the caller's frame types; windows-sys is the named pipe, the overlapped
+# I/O, the security descriptor, and the peer token/process queries.
 [dependencies]
 serde = { workspace = true }
 serde_json = { workspace = true }
 
@@ -395,6 +395,13 @@ pub enum ModSettingsCommand {
         #[arg(value_name = "key=value", required = true)]
         pairs: Vec<String>,
     },
+    /// Print the options a mod has written at runtime for its `$dynamicSelect`
+    /// settings, keyed by setting path, in the order the mod wrote them.
+    Options {
+        /// Mod ID.
+        #[arg(value_name = "id")]
+        id: String,
+    },
 }
 
 #[derive(Subcommand, Debug)]
@@ -404,6 +411,9 @@ pub enum AppCommand {
         #[command(subcommand)]
         command: AppSettingsCommand,
     },
+    /// Record the next keyboard shortcut pressed and print it in the form a
+    /// mod's hotkey setting stores (e.g. ctrl+alt+84).
+    CaptureHotkey,
 }
 
 #[derive(Subcommand, Debug)]
 
@@ -1,4 +1,4 @@
-//! A stub clang++ for the CLI's compile-bearing integration tests. It stands in
+//! A stub clang++ for testing the CLI's compile-bearing commands. It stands in
 //! for the real compiler at `<CompilerPath>/bin/clang++.exe` so `mod install` /
 //! `mod compile` / `mod update` can be driven without a toolchain, and doubles
 //! as the `update run` installer payload.
 
@@ -1,5 +1,5 @@
-//! A stub `schtasks.exe` for the CLI's registry-mode integration tests,
-//! the analogue of `stub_compiler`. The core toggles a Windows scheduled task
+//! A stub `schtasks.exe` for testing the CLI's registry-mode commands, the
+//! analogue of `stub_compiler`. The core toggles a Windows scheduled task
 //! via `schtasks.exe /change /tn <task> /enable|/disable` when `app settings
 //! set disableRunUIScheduledTask` is applied in registry mode; the
 //! `WINDHAWK_DEBUG_SCHTASKS_PATH` override points the core at this stub so the
 
@@ -3,14 +3,17 @@
 //! single setting through the preview restart gate and the post-write tray
 //! poke. The dotted-key schema, value parsing, and patch builder are the pure
 //! `validate::app_settings` helpers; this module owns the I/O (read, preview,
-//! apply, poke) and the render.
+//! apply, poke) and the render. `app capture-hotkey` records one keyboard
+//! chord through the core (the C ABI async path, the held modifiers streamed
+//! to stderr) and prints it in the form a mod's hotkey setting stores.
 
 use std::io::{self, Write};
 
 use serde_json::{Value, json};
 use windhawk_core_protocol::{
-    AppSettings, AppSettingsIntents, AppSettingsPatch, AppSettingsPatchParams, NotifyTrayParams,
-    TrayAction,
+    AppSettings, AppSettingsIntents, AppSettingsPatch, AppSettingsPatchParams,
+    CaptureHotkeyProgress, CaptureHotkeyResult, HotkeyCaptureCanceled, HotkeyModifiers,
+    NotifyTrayParams, OperationEvent, TrayAction,
 };
 
 use crate::Environment;
@@ -34,6 +37,83 @@ pub fn dispatch(
                 confirm_app_restart,
             } => set(env, &key, &value, confirm_app_restart),
         },
+        AppCommand::CaptureHotkey => capture_hotkey(env),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// app capture-hotkey
+// ---------------------------------------------------------------------------
+
+/// Record one chord. The hook the core installs takes every key while it runs,
+/// the console's Ctrl+C included, so the capture ends by the chord, a click on
+/// another window, or its own timeout; a Ctrl+C is a chord like any other.
+fn capture_hotkey(env: &Environment) -> Result<Box<dyn CommandResult>, CliError> {
+    env.logger.info("Press a shortcut...");
+    let result: CaptureHotkeyResult =
+        env.core
+            .invoke_async_as("captureHotkey", &json!({}), |event| match event {
+                OperationEvent::Progress { payload } => {
+                    // A payload this build does not decode is a newer core's;
+                    // nothing to show for it.
+                    if let Ok(progress) =
+                        serde_json::from_value::<CaptureHotkeyProgress>(payload.clone())
+                    {
+                        env.logger
+                            .info(&format!("Held: {}", held_label(progress.modifiers)));
+                    }
+                }
+                // The terminal events never reach this callback (the invoke consumes
+                // them); the catch-all keeps the match exhaustive.
+                OperationEvent::Installing
+                | OperationEvent::Completed { .. }
+                | OperationEvent::Failed { .. } => {}
+            })?;
+
+    match (result.hotkey, result.canceled) {
+        (Some(hotkey), _) => Ok(Box::new(CaptureHotkeyCliResult { hotkey })),
+        (None, canceled) => Err(CliError::cancelled(match canceled {
+            Some(HotkeyCaptureCanceled::FocusLost) => {
+                "The capture ended: another window came to the front."
+            }
+            Some(HotkeyCaptureCanceled::Timeout) => {
+                "The capture ended: no shortcut was pressed within the time allowed."
+            }
+            Some(HotkeyCaptureCanceled::Canceled) | None => "The capture was canceled.",
+        })),
+    }
+}
+
+/// The held modifiers as a person reads them (`Ctrl+Alt`), or `none`.
+fn held_label(modifiers: HotkeyModifiers) -> String {
+    let names: Vec<&str> = [
+        (modifiers.ctrl, "Ctrl"),
+        (modifiers.alt, "Alt"),
+        (modifiers.shift, "Shift"),
+        (modifiers.win, "Win"),
+    ]
+    .into_iter()
+    .filter(|(held, _)| *held)
+    .map(|(_, name)| name)
+    .collect();
+    if names.is_empty() {
+        "none".to_owned()
+    } else {
+        names.join("+")
+    }
+}
+
+struct CaptureHotkeyCliResult {
+    hotkey: String,
+}
+
+impl CommandResult for CaptureHotkeyCliResult {
+    fn json_data(&self) -> Value {
+        json!({ "hotkey": self.hotkey })
+    }
+
+    fn write_text(&self, out: &mut dyn Write) -> io::Result<()> {
+        writeln!(out, "{}", self.hotkey)
     }
 }
 
@@ -353,6 +433,26 @@ mod render_tests {
         assert_eq!(render_text(&list), "<empty list>\n");
     }
 
+    #[test]
+    fn capture_hotkey_renders_the_stored_form_and_labels_the_held_modifiers() {
+        let result = CaptureHotkeyCliResult {
+            hotkey: "ctrl+alt+84".to_owned(),
+        };
+        assert_eq!(render_text(&result), "ctrl+alt+84\n");
+        assert_eq!(result.json_data(), json!({ "hotkey": "ctrl+alt+84" }));
+
+        assert_eq!(
+            held_label(HotkeyModifiers {
+                ctrl: true,
+                alt: false,
+                shift: true,
+                win: true,
+            }),
+            "Ctrl+Shift+Win"
+        );
+        assert_eq!(held_label(HotkeyModifiers::default()), "none");
+    }
+
     #[test]
     fn app_settings_set_renders_restart_and_silent() {
         let restart = AppSettingsSetResult {
 
@@ -43,7 +43,7 @@ pub fn export(env: &Environment, args: DataExportArgs) -> Result<Box<dyn Command
     let result: ExportUserDataResult = env.core.invoke_as("exportUserData", &params)?;
 
     // Best-effort export: per-mod warnings go to stderr (they also ride in the
-    // `--json` summary), matching `data export` in the plan.
+    // `--json` summary).
     for warning in &result.summary.warnings {
         env.logger
             .warn(&format!("{}: {}", warning.mod_id, warning.message));
@@ -310,7 +310,7 @@ fn build_selection(flags: &SelectionFlags) -> Result<UserDataSelection, CliError
 }
 
 /// Reject a `--skip-*` / `--with-*` id that is not in the export scope (a usage
-/// error, exit 2, per CLI_SPEC). Only runs when there are per-mod overrides; a
+/// error, exit 2). Only runs when there are per-mod overrides; a
 /// keyword scope reads the installed set to resolve which ids it selects, while
 /// an explicit `--mods` list is the scope itself.
 #[track_caller]
 
@@ -1,7 +1,7 @@
 //! The `mod` group: `mod list`, `mod show`, `mod config get`/`set`, `mod
-//! settings get`/`set`, `mod enable`/`disable`, `mod remove` (sync), plus the
-//! compile-bearing async commands `mod install`, `mod update`, and `mod
-//! compile`.
+//! settings get`/`set`/`options`, `mod enable`/`disable`, `mod remove` (sync),
+//! plus the compile-bearing async commands `mod install`, `mod update`, and
+//! `mod compile`.
 
 mod config;
 mod install;
@@ -40,6 +40,7 @@ pub fn dispatch(
         ModCommand::Settings { command } => match command {
             ModSettingsCommand::Get { id, key } => settings::settings_get(env, &id, key.as_deref()),
             ModSettingsCommand::Set { id, pairs } => settings::settings_set(env, &id, &pairs),
+            ModSettingsCommand::Options { id } => settings::settings_options(env, &id),
         },
         ModCommand::Install(args) => install::install(env, args),
         ModCommand::Update(args) => install::update(env, args),
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-//! A stub clang++ for the CLI's compile-bearing integration tests. It stands in`
	`1`	`+//! A stub clang++ for testing the CLI's compile-bearing commands. It stands in`
`2`	`2`	//! for the real compiler at `<CompilerPath>/bin/clang++.exe` so `mod install` /
`3`	`3`	//! `mod compile` / `mod update` can be driven without a toolchain, and doubles
`4`	`4`	//! as the `update run` installer payload.