fix(shortcuts): harden Windows shortcut key tracking

Ignore the helper's own injected events: tag the Ctrl+V paste chord and modifier-masking releases with a sentinel dwExtraInfo and skip tagged events in HookCallback, so our synthetic input never feeds back into shortcut matching or pressed-key tracking. Mirrors the macOS helper's SELF_GENERATED_EVENT_TAG.

Forward shortcut-modifier events on the dedup path: when the helper still thinks a modifier is down (e.g. after a stale-key recheck cleared the app's copy), a genuine re-press looks like a duplicate here; emit it anyway for shortcut keys so the app can rebuild its active-key set on the first retry.

desktop: only re-run shortcut matching when the active-key set actually changes. addActiveKey/removeActiveKey now report whether the set changed and checkShortcuts is gated on it; redundant key events just refresh the recheck timestamp. Avoids the per-event matching/emit churn from forwarded auto-repeats.

Author: haritabh-z01

apps/desktop/src/main/managers/shortcut-manager.ts

@@ -226,27 +226,36 @@ export class ShortcutManager extends EventEmitter {
     if (!this.isKnownKeycode(keyCode)) {
       return;
     }
-    this.addActiveKey(keyCode);
-    this.checkShortcuts();
+    if (this.addActiveKey(keyCode)) {
+      this.checkShortcuts();
+    }
   }
 
   private handleKeyUp(payload: KeyEventPayload) {
     const keyCode = this.getKeycodeFromPayload(payload);
     if (!this.isKnownKeycode(keyCode)) {
       return;
     }
-    this.removeActiveKey(keyCode);
-    this.checkShortcuts();
+    if (this.removeActiveKey(keyCode)) {
+      this.checkShortcuts();
+    }
   }
 
-  private addActiveKey(keyCode: number) {
+  private addActiveKey(keyCode: number): boolean {
+    const wasActive = this.activeKeys.has(keyCode);
     this.activeKeys.set(keyCode, { keyCode, timestamp: Date.now() });
-    this.emitActiveKeysChanged();
+    if (!wasActive) {
+      this.emitActiveKeysChanged();
+    }
+    return !wasActive;
   }
 
-  private removeActiveKey(keyCode: number) {
-    this.activeKeys.delete(keyCode);
-    this.emitActiveKeysChanged();
+  private removeActiveKey(keyCode: number): boolean {
+    const changed = this.activeKeys.delete(keyCode);
+    if (changed) {
+      this.emitActiveKeysChanged();
+    }
+    return changed;
   }
 
   private removeActiveKeys(keyCodes: number[]) {

packages/native-helpers/windows-helper/src/KeycodeConstants.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 
 namespace WindowsHelper
@@ -27,5 +28,14 @@ internal static class KeycodeConstants
         };
 
         internal static readonly HashSet<int> ModifierKeyCodeSet = new(ModifierKeyCodes);
+
+        /// <summary>
+        /// Sentinel stamped into dwExtraInfo on keyboard events the helper injects itself
+        /// (the Ctrl+V paste chord and modifier-masking releases in AccessibilityService).
+        /// The low-level keyboard hook skips any event carrying this tag, so our own
+        /// synthetic input never feeds back into shortcut matching or pressed-key tracking.
+        /// Mirrors the macOS helper's SELF_GENERATED_EVENT_TAG (0x414D4943414C5048 = "AMICALPH").
+        /// </summary>
+        internal static readonly IntPtr SelfInjectedEventTag = unchecked((IntPtr)0x414D4943414C5048L);
     }
 }

packages/native-helpers/windows-helper/src/Services/AccessibilityService.cs

@@ -149,7 +149,7 @@ private static INPUT CreateKeyboardInput(ushort virtualKey, uint flags = 0)
                         wScan = 0,
                         dwFlags = flags,
                         time = 0,
-                        dwExtraInfo = IntPtr.Zero,
+                        dwExtraInfo = KeycodeConstants.SelfInjectedEventTag,
                     }
                 }
             };

packages/native-helpers/windows-helper/src/ShortcutMonitor.cs

@@ -135,20 +135,32 @@ private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
                     {
                         var kbStruct = Marshal.PtrToStructure<KBDLLHOOKSTRUCT>(lParam);
 
+                        // Skip our own injected events (tagged dwExtraInfo) to avoid feedback loops.
+                        if (kbStruct.dwExtraInfo == KeycodeConstants.SelfInjectedEventTag)
+                        {
+                            return CallNextHookEx(hookId, nCode, wParam, lParam);
+                        }
+
                         var vkCode = (int)kbStruct.vkCode;
                         var isModifier = IsModifierKey(kbStruct.vkCode);
 
                         if (isModifier)
                         {
                             var wasDown = ShortcutManager.Instance.IsModifierPressed(vkCode);
                             var isDown = isKeyDown;
+                            var isShortcutKey = ShortcutManager.Instance.IsShortcutKey(vkCode);
 
                             if (wasDown == isDown)
                             {
+                                if (isShortcutKey)
+                                {
+                                    EmitKeyEvent(isDown ? HelperEventType.KeyDown : HelperEventType.KeyUp, vkCode);
+                                }
+
                                 return CallNextHookEx(hookId, nCode, wParam, lParam);
                             }
 
-                            if (ShortcutManager.Instance.IsShortcutKey(vkCode))
+                            if (isShortcutKey)
                             {
                                 var resyncResult = ShortcutManager.Instance.ValidateAndResyncKeyState(vkCode);
                                 EmitResyncKeyEvents(resyncResult, vkCode);