feat: per-device capture — every online device gets its own session, bindings, and settings

[tagawa0525]

Problem

The runtime manages only the GUI-selected device. With more than one mouse connected this produces two real defects:

1. The non-selected device's settings are dead. Its thumbwheel rebinds, sensitivity, and button captures silently stop applying the moment you switch the carousel to another device.
2. The Linux evdev hook applies the selected device's profile to every mouse it grabs — including other vendors' mice and virtual pointers (e.g. keyd's). Side-button remaps configured for an MX Master land on whatever other pointing device you plug in.

Design

Capture moves to the HID++ layer per device, where device identity is structural (one channel per device) instead of inferred:

• capture_plan (agent-core, new): the orchestrator rebuilds one DeviceCapturePlan per online device — route, per-device binding maps, divert set, effective thumbwheel sensitivity — on every config / app / inventory change, including pure online-flag flips.
• Plan-driven sessions (openlogi-hid): run_capture_session takes a CaptureSpec. Rebindable standard buttons (middle/back/forward, 0x0052/0x0053/0x0056) divert over 0x1b04 and dispatch as ButtonPressed. A button at its default binding is never diverted, so native behavior needs no re-synthesis; the OS-hook gesture owner's button is likewise excluded so hold+swipe keeps its events.
• Multi-session watcher: sessions live in a map keyed by config key; inputs arrive tagged with their device and dispatch against that device's own plan (per-device thumbwheel accumulators included). The capture-vs-pairing lease is shared across sessions via an Arc and frees itself when the last session exits — pairing semantics unchanged.
• Per-device settings: DeviceConfig.thumbwheel_sensitivity overrides the app-wide default (which remains the fallback and keeps its Settings → General slider); the SmartShift panel gains a per-device sensitivity slider (existing localized label, no new i18n keys). DpiCycles replaces the single cycle state: HID++ dispatch cycles the device an event arrived on, the OS hook (which cannot attribute events) keeps targeting the selection, and a config reload no longer snaps an unchanged device's cycle index back to preset[0].
• Per-device manage toggle: DeviceConfig.enabled (default true). A disabled device is left fully native — no capture session, no volatile re-apply, no DPI-cycle entry, empty hook maps. The Home gallery ring now shows managed state (accent blue = managed, red = disabled) instead of marking the selection, since capture no longer depends on it.
• Linux hook: grabs only Logitech (VID 046d) mice, mirroring the macOS hook's vendor awareness.

Verification

On real hardware (MX Master 4 + MX Master 3S on two Bolt receivers, Linux/Wayland):

• Both devices hold concurrent capture sessions; side buttons, gesture swipes/click, DPI button, thumbwheel rotation and (3S) single tap all arrive correctly attributed with no OS hook involved, and every diverted control restores on teardown.
• Independent per-device behavior confirmed live: different thumbwheel directions and sensitivities on each mouse simultaneously, regardless of carousel selection.
• cargo fmt --check, cargo clippy --workspace --all-targets -- -D warnings, cargo test --workspace all pass.

HID++-layer changes are platform-neutral; runtime testing was on Linux (the OS-hook change is Linux-only).

Notes

• The first two commits are fix: divert thumbwheel for rotation rebinds even without single-tap capability #415 (thumbwheel divert fix) — this branch builds on it; if fix: divert thumbwheel for rotation rebinds even without single-tap capability #415 merges first this PR rebases to just the five feature commits.
• Known limitation kept intentionally small: the OS hook still applies the selection's profile to the (now Logitech-only) devices it grabs; fully per-device hook dispatch would need evdev device attribution plumbed through the hook and is left for a follow-up.

🤖 Generated with Claude Code

https://claude.ai/code/session_01N76prZoUHMrHZajXq4jET1

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[greptile-apps]

Greptile Summary

This PR refactors the runtime from a single-device capture model to a fully per-device one: the orchestrator now builds one DeviceCapturePlan per online device, a multi-session watcher runs one HID++ capture session per device (diffing on plan changes), and DPI cycle state lives in a per-device map (DpiCycles) keyed by config key. It also adds a per-device enabled toggle and a per-device thumbwheel-sensitivity override.

• Per-device sessions (watchers/gesture.rs): Sessions are keyed by config key; a stopped session stays tracked (with its stop sender taken) until done_rx confirms full teardown, preventing the new session's arm_controls from racing the old session's restore writes.
• DpiCycles + DpiCycleState preservation: rebuild_dpi_cycles retains each device's live index and capabilities when presets are unchanged, and is now called in both the full rebuild() path and the inventory fast path (!changed online-flag flip) via publish_device_runtime.
• Linux evdev hook: Filtered to Logitech VID 0x046d, mirroring macOS vendor awareness and avoiding grabbing unrelated pointing devices.

Confidence Score: 5/5

Safe to merge. The multi-session teardown design correctly prevents control-divert races on plan changes, and publish_device_runtime is now called in every orchestrator code path so capture plans and DPI cycles stay in sync for all device lifecycle events.

The overall architecture is sound: per-device CaptureSpec equality gates session restarts, the channel-slot clear guards against evicting a sibling session's channel, and the Logitech-only hook filter fixes the cross-vendor remap defect. The one finding — capture_plans.read() staying alive during dispatch_action for gesture/button events — is a minor read-lock extension, not a correctness bug.

Files Needing Attention: crates/openlogi-agent-core/src/watchers/gesture.rs — the dispatch function's lock-hold pattern is the only area worth a second look.

Important Files Changed

Filename	Overview
crates/openlogi-agent-core/src/capture_plan.rs	New file: builds DeviceCapturePlan per device — divert set, binding maps, thumbwheel flags — with clear unit tests covering the gesture-button divert edge cases.
crates/openlogi-agent-core/src/watchers/gesture.rs	Multi-session manager: stopped sessions stay in the map until done_rx confirms teardown, preventing arm/restore races. dispatch holds capture_plans.read() during dispatch_action for Gesture/ButtonPressed because the action borrows from the plan — adding .cloned() would let NLL release the lock sooner (same as the Scroll arm already does).
crates/openlogi-agent-core/src/orchestrator.rs	Replaces single-device DPI+sensitivity state with per-device DpiCycles; publish_device_runtime is now called in every code path (full rebuild, inventory fast-path, app switch), ensuring capture plans and DPI cycles stay in sync.
crates/openlogi-agent-core/src/dpi.rs	New DpiCycles struct wraps per-device DpiCycleState map; state_for/target_for correctly fall back to the selected device for the OS-hook path (None key).
crates/openlogi-hid/src/gesture.rs	Adds CaptureSpec and DIVERTABLE_STANDARD_BUTTONS; correctly guards the channel-slot clear on teardown with Arc::ptr_eq to avoid evicting a sibling session's channel; separates plain-diverted gesture button from swipe accumulator path.
crates/openlogi-core/src/config/device.rs	Adds enabled (default true, skip-serialize-if-true) and thumbwheel_sensitivity: Option<i32> to DeviceConfig with backward-compatible serde defaults.
crates/openlogi-gui/src/state.rs	Adds set_device_enabled and set_device_thumbwheel_sensitivity; the sensitivity setter clears the per-device override when the user slides to the app-wide default, keeping config.toml clean.
crates/openlogi-hook/src/linux.rs	Adds Logitech VID filter to find_mouse_devices, preventing the hook from grabbing unrelated vendors' pointing devices.
crates/openlogi-gui/src/components/smartshift_panel.rs	Adds per-device thumbwheel sensitivity slider; re-seats the slider from committed config only when not mid-drag, following the same safe pattern as the existing SmartShift threshold slider.

Sequence Diagram

sequenceDiagram
    participant Orch as Orchestrator
    participant Plans as SharedCapturePlans
    participant Mgr as gesture::manage (async)
    participant Sess as run_capture_session (task)
    participant Fwd as forward task
    participant DPI as DpiCycles

    Orch->>Plans: write capture_plans (publish_device_runtime)
    Orch->>DPI: write dpi_cycle (rebuild_dpi_cycles)

    Note over Mgr: ticker fires
    Mgr->>Plans: read → build want map
    Mgr->>Sess: spawn_session(key, route, spec, epoch, lease)
    Sess->>Fwd: spawn forward task (key-tags inputs)

    Note over Sess: arm_controls → divert CIDs
    Sess-->>Fwd: CapturedInput via session_tx
    Fwd-->>Mgr: (key, input) via tx

    Note over Mgr: rx.recv() branch
    Mgr->>Plans: read → find plan by key
    Mgr->>DPI: write (CycleDpiPresets / SetDpiPreset)

    Note over Mgr: plan changes — ticker fires
    Mgr->>Sess: stop.send() — stop sender taken
    Note over Sess: restore diverted CIDs, drop session_tx
    Fwd-->>Mgr: None (session_tx dropped) — forward task exits
    Sess-->>Mgr: done.send((key, epoch))
    Note over Mgr: done_rx: sessions.remove(key)
    Note over Mgr: next tick: new session started

Loading

_{Reviews (9): Last reviewed commit: "fix(hid): only clear the capture-channel..." | Re-trigger Greptile}

[tagawa0525]

Both review findings addressed in 170cfbe:

• DPI cycles on the inventory fast path: the same-set/fresh-online-flags branch now goes through a single publish_device_runtime() that rewrites the capture plans and the per-device DPI-cycle map together, so a waking device gets both its session and its DPI slot — and the two views can't diverge again by construction.
• ToggleSmartShift write lock: DpiCycles gained a read-only target_for() (with a unit test covering the explicit-key and selection-fallback paths) and the toggle now takes only a read lock.

[tagawa0525]

The remaining cross-tick window flagged in the re-review summary is closed in e277c5b: a deliberately stopped session now stays tracked (stop sender taken) until its task's completion report arrives — which is sent only after run_capture_session returns, restore writes included — and a tracked key is never re-armed. This covers both plan changes and the post-pairing recovery path, no matter how many ticks the teardown takes.

[tagawa0525]

Fixed in b00d213: set_current_app now routes through publish_device_runtime(), so the capture plans (binding maps and divert sets, both per-app effective) are republished whenever the foreground app changes. Covered by app_switch_republishes_capture_plans (RED in 2985353). DPI cycle state is preserved across the republish since presets are not app-scoped.

[tagawa0525]

On the two P2 notes from the latest review pass:

• Sensitivity override not clearable to None: fixed in 8065e4c. Committing the per-device slider at the app-wide default now clears the override (the slider is the device's only sensitivity control, so landing on the default is the "no override" gesture), and the no-op guard compares the stored override rather than the effective value so an existing pinned-at-default override actually clears.
• Forwarding-task drain ordering: keeping as is. Dispatch deliberately resolves every input against the plans in force at dispatch time (same event-time semantics as the OS hook on a config edit), so a buffered input from a stopping session is interpreted exactly as if it had arrived a moment later — reordering done behind the forwarding drain wouldn't change which plan those one or two events hit, and no hardware write is involved.

[tagawa0525]

Fixed in b57b279: the teardown clear is now guarded by an Arc::ptr_eq identity check, so a stopping session only removes its own published channel and never evicts a sibling session's.