diff --git a/doc-dev/reference-manual.md b/doc-dev/reference-manual.md
index 01823110f..8c000a940 100644
--- a/doc-dev/reference-manual.md
+++ b/doc-dev/reference-manual.md
@@ -149,13 +149,12 @@ COMMAND = set secondaryRole.defaultStrategy { simple | advanced }
 COMMAND = set secondaryRole.advanced.timeout <ms, 0-500 (INT)>
 COMMAND = set secondaryRole.advanced.timeoutAction { primary | secondary | none }
 COMMAND = set secondaryRole.advanced.safetyMargin <ms, higher value adjusts sensitivity towards primary role -50-50 (INT)>
-COMMAND = set secondaryRole.advanced.triggerByPress <trigger immediately on action key press (BOOL)>
-COMMAND = set secondaryRole.advanced.triggerByRelease <trigger secondary role if action key is released before dual role (BOOL)>
+COMMAND = set secondaryRole.advanced.triggeringEvent { press | release | none } <determines whether secondary role is triggered when another key is pressed or when another key is pressed and released while the secondary role key is being held, or not at all from other keys being pressed>
 COMMAND = set secondaryRole.advanced.triggerByMouse <trigger secondary role immediately on mouse move (BOOL)
 COMMAND = set secondaryRole.advanced.minimumHoldTime <ms, minimum time a key must be held before it can trigger secondary role 0-255 (INT)>
 COMMAND = set secondaryRole.advanced.doubletapToPrimary <hold primary on doubletap (BOOL)>
 COMMAND = set secondaryRole.advanced.doubletapTime <ms, 0-500 (INT)>
-COMMAND = set secondaryRole.advanced.primaryFromSameHalf <prevents secondary role keys from triggering as secondary when the triggering key is from the same half of the keyboard (BOOL)>
+COMMAND = set secondaryRole.advanced.acceptTriggersFromSameHalf <prevents secondary role keys from triggering as secondary from triggers from the same half of the keyboard (BOOL)>
 COMMAND = set mouseKeys.{move|scroll}.initialSpeed <px/s, ~100/20 (INT)>
 COMMAND = set mouseKeys.{move|scroll}.baseSpeed <px/s, ~800/20 (INT)>
 COMMAND = set mouseKeys.{move|scroll}.initialAcceleration <px/s, ~1700/20 (INT)>
@@ -195,7 +194,7 @@ CONDITION = if (EXPRESSION)
 CONDITION = else
 CONDITION = {ifShortcut | ifNotShortcut} [IFSHORTCUT_OPTIONS]* [KEYID]+
 CONDITION = {ifGesture | ifNotGesture} [IFSHORTCUT_OPTIONS]* [KEYID]+
-CONDITION = {ifPrimary | ifSecondary} [ simpleStrategy | advancedStrategy | primaryFromSameHalf | primaryFromSameHalfDisabled ]
+CONDITION = {ifPrimary | ifSecondary} [ simpleStrategy | advancedStrategy | ignoreTriggersFromSameHalf | acceptTriggersFromSameHalf ]
 CONDITION = {ifHold | ifTap}
 CONDITION = {ifDoubletap | ifNotDoubletap}
 CONDITION = {ifInterrupted | ifNotInterrupted}
@@ -326,6 +325,8 @@ ZEPHYR_COMMAND = uhk { connections | mouseMultipliers | rollover BOOL | charger
 COMMAND = set macroEngine.scheduler {blocking|preemptive}
 COMMAND = set doubletapDelay <time in ms, at most 65535, alias to doubletapTimeout (INT)>
 COMMAND = set modifierLayerTriggers.{control} {left|right|both}
+COMMAND = set secondaryRole.advanced.triggerByPress <trigger immediately on action key press (BOOL)>
+COMMAND = set secondaryRole.advanced.triggerByRelease <trigger secondary role if action key is released before dual role (BOOL)>
 COMMAND = untoggleLayer
 LAYERID = control
 ###########
@@ -482,7 +483,7 @@ Commands:
 - `holdLayer LAYERID` mostly corresponds to the sequence `toggleLayer <layer>; delayUntilRelease; untoggleLayer`, except for more elaborate conflict resolution (releasing holds in incorrect order).
 - `holdKeymapLayer KEYMAPID LAYERID` just as holdLayer, but allows referring to layer of different keymap. This reloads the entire keymap, so it may be very inefficient.
 - `holdLayerMax/holdKeymapLayerMax` will timeout after <timeout> ms if no action is performed in that time.
-- `ifPrimary/ifSecondary [ simpleStrategy | advancedStrategy | primaryFromSameHalf | primaryFromSameHalfDisabled ]... COMMAND` will wait until the firmware can distinguish whether primary or secondary action should be activated and then either execute `COMMAND` or skip it.
+- `ifPrimary/ifSecondary [ simpleStrategy | advancedStrategy | ignoreTriggersFromSameHalf | acceptTriggersFromSameHalf ]... COMMAND` will wait until the firmware can distinguish whether primary or secondary action should be activated and then either execute `COMMAND` or skip it.
 
 ### Layer/Keymap loading manipulation / shared layers:
 
@@ -506,7 +507,7 @@ We allow postponing key activations in order to allow deciding between some scen
 - `ifKeyPendingAt/ifNotKeyPendingAt <idx> <keyId>` looks into postponing queue at `idx`th waiting key and compares it to the `keyId`.
 - `consumePending <n>` will remove n records from the queue.
 - `activateKeyPostponed KEYID` will add tap of KEYID at the end of queue. If `atLayer LAYERID` is specified, action will be taken from that layer rather than current one. If `prepend` option is specified, event will be place at the beginning of the queue.
-- `ifPrimary/ifSecondary [ simpleStrategy | advancedStrategy | primaryFromSameHalf | primaryFromSameHalfDisabled ] ... COMMAND` will wait until the firmware can distinguish whether primary or secondary action should be activated and then either execute `COMMAND` or skip it.
+- `ifPrimary/ifSecondary [ simpleStrategy | advancedStrategy | ignoreTriggersFromSameHalf | acceptTriggersFromSameHalf ] ... COMMAND` will wait until the firmware can distinguish whether primary or secondary action should be activated and then either execute `COMMAND` or skip it.
 - `ifHold/ifTap COMMAND` will wait until the key that activated the macro will be released or until holdTimeout elapses. Then it will either execute the command or skip it.
 - `ifShortcut/ifNotShortcut/ifGesture/ifNotGesture [IFSHORTCUT_OPTIONS]* [KEYID]*` will wait for next keypresses until sufficient number of keys has been pressed. If the next keypresses correspond to the provided arguments (hardware ids), the keypresses are consumed and the condition is performed. Consuming takes place in both `if` and `ifNot` versions if the full list is matched. E.g., `ifShortcut 090 089 final tapKey C-V; holdKey v`.
   - `Shortcut` requires continual press of keys (e.g., Ctrl+c). By default, it timeouts with the activation key release.
@@ -546,7 +547,7 @@ Conditions are checked before processing the rest of the command. If the conditi
 - `ifRecording/ifNotRecording` and `ifRecordingId/ifNotRecordingId MACROID` test if the runtime macro recorder is in the recording state.
 - `ifShortcut/ifNotShortcut [IFSHORTCUT_OPTIONS]* [KEYID]*` will wait for future keypresses and compare them to the argument. See the postponer mechanism section.
 - `ifGesture/ifNotGesture [IFSHORTCUT_OPTIONS]* [KEYID]*` just as `ifShortcut`, but breaks after 1000ms instead of when the key is released. See the postponer mechanism section.
-- `ifPrimary/ifSecondary [ simpleStrategy | advancedStrategy | primaryFromSameHalf | primaryFromSameHalfDisabled ] ... COMMAND` will wait until the firmware can distinguish whether primary or secondary action should be activated and then either execute `COMMAND` or skip it.
+- `ifPrimary/ifSecondary [ simpleStrategy | advancedStrategy | ignoreTriggersFromSameHalf | acceptTriggersFromSameHalf ] ... COMMAND` will wait until the firmware can distinguish whether primary or secondary action should be activated and then either execute `COMMAND` or skip it.
 
 ### Modifiers
 
@@ -703,14 +704,13 @@ Key actions can be parametrized with macro arguments. These arguments can be exp
     - advanced strategy may trigger secondary role depending on timeout, or depending on key release order.
       - `set secondaryRole.advanced.timeout <timeout in ms, 350 (INT)>` if this timeout is reached, `timeoutAction` (secondary by default) role is activated.
       - `set secondaryRole.advanced.timeoutAction { primary | secondary | none}` defines whether the primary action or the secondary role, or no action at all, should be activated when timeout is reached
-      - `set secondaryRole.advanced.triggerByRelease BOOL` if enabled, secondary role is chosen depending on the release order of the keys (`press-A, press-B, release-B, release-A` leads to secondary action; `press-A, press-B, release-A, release-B` leads to primary action). This is further modified by safetyMargin.
-      - `set secondaryRole.advanced.triggerByPress BOOL` if enabled, secondary role is triggered when there is another press, simiarly to the simple strategy. Unlike simple strategy, this allows setting timeout behaviors, and also is modified by safetyMargin.
+      - `set secondaryRole.advanced.triggeringEvent { press | release | none }` determines whether a secondary role key is triggered as secondary if another key is pressed while it's held, if another key is pressed and released while it's held, or not at all from other keys being held.  The third option allows usage of the timeout feature without inter-key triggers.
       - `set secondaryRole.advanced.triggerByMouse BOOL` if enabled, any mouse (module) activity triggers secondary role immediately.
       - `set secondaryRole.advanced.minimumHoldTime <ms, 0-255 (INT)>` sets the minimum time that a key must be held before it is allowed to trigger as secondary role.
       - `set secondaryRole.advanced.safetyMargin <ms, -50 - 50 (INT)>` finetunes sensitivity of the trigger-by-release and trigger-by-press behaviours, so that positive values favor primary role, while negative values favor secondary role. This works by adding the value to the action key (or subtracting from the dual role key). E.g., suppose trigger by release is active, and safetyMargin equal 50. Furthermore assume that dual-role key is released 30ms after the action key. Due to safety margin 50 being greater than 30, the dual-role key is still considered to be released first, and so primary role is activated.
       - `set secondaryRole.advanced.doubletapToPrimary BOOL` allows switching timeout action to primary by doubletap to allow holding the primary action (Useful if you want a dual key on space.)
       - `set secondaryRole.advanced.doubletapTime <ms, 200 (INT)>` configures the above timeout (measured press-to-press).
-      - `set secondaryRole.advanced.primaryFromSameHalf <(BOOL)>` enables or disables whether secondary role keys can trigger their secondary role if the triggering key is from the same keyboard half.  `ifPrimary/ifSecondary` can specify explicitly whether to trigger primary from same half using the argument `primaryFromSameHalf/primaryFromSameHalfDisabled`.
+      - `set secondaryRole.advanced.acceptTriggersFromSameHalf <(BOOL)>` enables or disables whether secondary role keys can trigger their secondary role from key events from the same keyboard half.  `ifPrimary/ifSecondary` can specify explicitly whether to allow secondary triggers from same half using the argument `ignoreTriggersFromSameHalf/acceptTriggersFromSameHalf`.
 
 - `macroEngine`
   - terminology:
diff --git a/doc-dev/user-guide.md b/doc-dev/user-guide.md
index b01936a33..2578b4e9d 100644
--- a/doc-dev/user-guide.md
+++ b/doc-dev/user-guide.md
@@ -443,7 +443,7 @@ set secondaryRole.defaultStrategy advanced
 set secondaryRole.advanced.timeout 350
 set secondaryRole.advanced.timeoutAction secondary
 set secondaryRole.advanced.safetyMargin 50
-set secondaryRole.advanced.triggerByRelease 1
+set secondaryRole.advanced.triggeringEvent release
 set secondaryRole.advanced.doubletapToPrimary 0
 ```
 
@@ -456,7 +456,7 @@ set secondaryRole.defaultStrategy advanced
 set secondaryRole.advanced.timeout 200
 set secondaryRole.advanced.timeoutAction secondary
 set secondaryRole.advanced.safetyMargin 0
-set secondaryRole.advanced.triggerByRelease 0
+set secondaryRole.advanced.triggeringEvent none
 set secondaryRole.advanced.doubletapToPrimary 1
 set secondaryRole.advanced.doubletapTime 200
 ```
@@ -468,8 +468,7 @@ set secondaryRole.defaultStrategy advanced
 set secondaryRole.advanced.timeout 500
 set secondaryRole.advanced.timeoutAction secondary
 set secondaryRole.advanced.safetyMargin 0
-set secondaryRole.advanced.triggerByRelease 0
-set secondaryRole.advanced.triggerByPress 1
+set secondaryRole.advanced.triggeringEvent press
 set secondaryRole.advanced.doubletapToPrimary 1
 set secondaryRole.advanced.doubletapTime 200
 ```
@@ -478,14 +477,14 @@ Firngrod's Home Row Mods (HRM) configuration (Recommended):
 
 ```
 set secondaryRole.defaultStrategy advanced
-set secondaryRole.advanced.triggerByRelease 1
+set secondaryRole.advanced.triggeringEvent release
 set secondaryRole.advanced.timeout 300
 set secondaryRole.advanced.timeoutAction secondary
 set secondaryRole.advanced.doubletapToPrimary 1
 set secondaryRole.advanced.safetyMargin -100
 set secondaryRole.advanced.triggerByMouse 1
 set secondaryRole.advanced.minimumHoldTime 150
-set secondaryRole.advanced.primaryFromSameHalf 1
+set secondaryRole.advanced.acceptTriggersFromSameHalf 0
 ```
 
 Full set of advanced strategy config values follows (for copy-paste convenience):
@@ -495,13 +494,12 @@ set secondaryRole.defaultStrategy advanced
 set secondaryRole.advanced.timeout 500
 set secondaryRole.advanced.timeoutAction secondary
 set secondaryRole.advanced.safetyMargin 0
-set secondaryRole.advanced.triggerByRelease 0
-set secondaryRole.advanced.triggerByPress 0
+set secondaryRole.advanced.triggeringEvent press
 set secondaryRole.advanced.triggerByMouse 0
 set secondaryRole.advanced.doubletapToPrimary 1
 set secondaryRole.advanced.doubletapTime 200
 set secondaryRole.advanced.minimumHoldTime 0
-set secondaryRole.advanced.primaryFromSameHalf 0
+set secondaryRole.advanced.acceptTriggersFromSameHalf 1
 ```
 
 The above configuration will trigger the secondary role whenever the dual-role key is pressed for more than 200ms, i.e., just a very slightly prolonged activation will trigger the secondary role.
diff --git a/right/src/config_manager.c b/right/src/config_manager.c
index 1bb4cfbb7..0e3de1371 100644
--- a/right/src/config_manager.c
+++ b/right/src/config_manager.c
@@ -216,13 +216,12 @@ const config_t DefaultCfg = (config_t){
         .SecondaryRoles_AdvancedStrategyDoubletapTimeout = 200,
         .SecondaryRoles_AdvancedStrategyTimeout = 350,
         .SecondaryRoles_AdvancedStrategySafetyMargin = 50,
-        .SecondaryRoles_AdvancedStrategyTriggerByRelease = true,
-        .SecondaryRoles_AdvancedStrategyTriggerByPress = false,
+        .SecondaryRoles_AdvancedStrategyTriggeringEvent = SecondaryRoleTriggeringEvent_Release,
         .SecondaryRoles_AdvancedStrategyTriggerByMouse = false,
         .SecondaryRoles_AdvancedStrategyMinimumHoldTime = 0,
         .SecondaryRoles_AdvancedStrategyDoubletapToPrimary = true,
         .SecondaryRoles_AdvancedStrategyTimeoutAction = SecondaryRoleState_Secondary,
-        .SecondaryRoles_AdvancedStrategyPrimaryFromSameHalf = false,
+        .SecondaryRoles_AdvancedStrategyAcceptTriggersFromSameHalf = true,
         .SecondaryRoles_Strategy = SecondaryRoleStrategy_Simple,
         .StickyModifierStrategy = Stick_Smart,
         .Macros_Scheduler = Scheduler_Blocking,
diff --git a/right/src/config_manager.h b/right/src/config_manager.h
index 0d1c20e7a..265c827e5 100644
--- a/right/src/config_manager.h
+++ b/right/src/config_manager.h
@@ -30,12 +30,11 @@
 
         // secondary roles
         secondary_role_strategy_t SecondaryRoles_Strategy;
-        bool SecondaryRoles_AdvancedStrategyPrimaryFromSameHalf;
+        bool SecondaryRoles_AdvancedStrategyAcceptTriggersFromSameHalf;
         uint16_t SecondaryRoles_AdvancedStrategyDoubletapTimeout;
         uint16_t SecondaryRoles_AdvancedStrategyTimeout;
         int16_t SecondaryRoles_AdvancedStrategySafetyMargin;
-        bool SecondaryRoles_AdvancedStrategyTriggerByRelease;
-        bool SecondaryRoles_AdvancedStrategyTriggerByPress;
+        secondary_role_triggering_event_t SecondaryRoles_AdvancedStrategyTriggeringEvent;
         bool SecondaryRoles_AdvancedStrategyTriggerByMouse;
         bool SecondaryRoles_AdvancedStrategyDoubletapToPrimary;
         secondary_role_state_t SecondaryRoles_AdvancedStrategyTimeoutAction;
diff --git a/right/src/config_parser/parse_config.c b/right/src/config_parser/parse_config.c
index 6920949d4..1ca03d70c 100644
--- a/right/src/config_parser/parse_config.c
+++ b/right/src/config_parser/parse_config.c
@@ -182,7 +182,7 @@ parser_error_t parseConfig(config_buffer_t *buffer)
     uint16_t secondaryRoles_AdvancedStrategyDoubletapTimeout = Cfg.SecondaryRoles_AdvancedStrategyDoubletapTimeout;
     uint16_t secondaryRoles_AdvancedStrategyTimeout = Cfg.SecondaryRoles_AdvancedStrategyTimeout;
     int16_t secondaryRoles_AdvancedStrategySafetyMargin = Cfg.SecondaryRoles_AdvancedStrategySafetyMargin;
-    bool secondaryRoles_AdvancedStrategyTriggerByRelease = Cfg.SecondaryRoles_AdvancedStrategyTriggerByRelease;
+    secondary_role_triggering_event_t secondaryRoles_AdvancedStrategyTriggeringEvent = Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent;
     bool secondaryRoles_AdvancedStrategyDoubletapToPrimary = Cfg.SecondaryRoles_AdvancedStrategyDoubletapToPrimary;
     serialized_secondary_role_action_type_t secondaryRoles_AdvancedStrategyTimeoutAction = SerializedSecondaryRoleActionType_Secondary;
 
@@ -191,7 +191,7 @@ parser_error_t parseConfig(config_buffer_t *buffer)
         secondaryRoles_AdvancedStrategyDoubletapTimeout = ReadUInt16(buffer);
         secondaryRoles_AdvancedStrategyTimeout = ReadUInt16(buffer);
         secondaryRoles_AdvancedStrategySafetyMargin = ReadInt16(buffer);
-        secondaryRoles_AdvancedStrategyTriggerByRelease = ReadBool(buffer);
+        secondaryRoles_AdvancedStrategyTriggeringEvent = ReadBool(buffer) ? SecondaryRoleTriggeringEvent_Release : SecondaryRoleTriggeringEvent_Press;
         secondaryRoles_AdvancedStrategyDoubletapToPrimary = ReadBool(buffer);
         secondaryRoles_AdvancedStrategyTimeoutAction = ReadUInt8(buffer);
 
@@ -349,7 +349,7 @@ parser_error_t parseConfig(config_buffer_t *buffer)
             Cfg.SecondaryRoles_AdvancedStrategyDoubletapTimeout = secondaryRoles_AdvancedStrategyDoubletapTimeout;
             Cfg.SecondaryRoles_AdvancedStrategyTimeout = secondaryRoles_AdvancedStrategyTimeout;
             Cfg.SecondaryRoles_AdvancedStrategySafetyMargin = secondaryRoles_AdvancedStrategySafetyMargin;
-            Cfg.SecondaryRoles_AdvancedStrategyTriggerByRelease = secondaryRoles_AdvancedStrategyTriggerByRelease;
+            Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent = secondaryRoles_AdvancedStrategyTriggeringEvent;
             Cfg.SecondaryRoles_AdvancedStrategyDoubletapToPrimary = secondaryRoles_AdvancedStrategyDoubletapToPrimary;
             switch (secondaryRoles_AdvancedStrategyTimeoutAction) {
                 case SerializedSecondaryRoleActionType_Primary:
diff --git a/right/src/key_states.h b/right/src/key_states.h
index 8af72b983..e9e44e3d4 100644
--- a/right/src/key_states.h
+++ b/right/src/key_states.h
@@ -53,4 +53,13 @@
     static inline bool KeyState_DeactivatedEarlier(key_state_t* s) { return !s->previous && !s->current; };
     static inline bool KeyState_NonZero(key_state_t* s) { return s->previous || s->current; };
 
+    static inline bool KeyState_IsRightHalf(key_state_t* s) { return s < &KeyStates[1][0]; };
+    static inline bool KeyState_IsLeftHalf(key_state_t* s) { return s < &KeyStates[2][0] && s >= &KeyStates[1][0]; };
+    static inline bool KeyState_IsKeyCluster(key_state_t* s) { return s >= &KeyStates[2][0] && s < &KeyStates[3][0]; };
+    static inline bool KeyState_IsMouseModule(key_state_t* s) { return s >= &KeyStates[3][0]; };
+    static inline bool KeyState_IsModule(key_state_t* s) { return s >= &KeyStates[2][0]; };
+    static inline bool KeyState_IsRightSide(key_state_t* s) { return KeyState_IsRightHalf(s) || KeyState_IsMouseModule(s); };
+    static inline bool KeyState_IsLeftSide(key_state_t* s) { return s >= &KeyStates[1][0] && s < &KeyStates[3][0]; };
+
+
 #endif
diff --git a/right/src/macros/commands.c b/right/src/macros/commands.c
index 23e4d310f..3c2e6576a 100644
--- a/right/src/macros/commands.c
+++ b/right/src/macros/commands.c
@@ -1006,11 +1006,11 @@ static macro_result_t processIfSecondaryCommand(parser_context_t* ctx, bool nega
             strategy = SecondaryRoleStrategy_Advanced;
         }
 
-        if (ConsumeToken(ctx, "primaryFromSameHalf")) {
-            fromSameHalf = SecondaryRole_PrimaryFromSameHalf;
+        if (ConsumeToken(ctx, "ignoreTriggersFromSameHalf")) {
+            fromSameHalf = SecondaryRole_IgnoreTriggersFromSameHalf;
         }
-        else if (ConsumeToken(ctx, "primaryFromSameHalfDisabled")) {
-            fromSameHalf = SecondaryRole_PrimaryFromSameHalfDisabled;
+        else if (ConsumeToken(ctx, "acceptTriggersFromSameHalf")) {
+            fromSameHalf = SecondaryRole_AcceptTriggersFromSameHalf;
         }
         else {
             break;
diff --git a/right/src/macros/set_command.c b/right/src/macros/set_command.c
index d8dd146b3..e6411590f 100644
--- a/right/src/macros/set_command.c
+++ b/right/src/macros/set_command.c
@@ -301,10 +301,16 @@ static macro_variable_t secondaryRoleAdvanced(parser_context_t* ctx, set_command
         ASSIGN_INT(Cfg.SecondaryRoles_AdvancedStrategySafetyMargin);
     }
     else if (ConsumeToken(ctx, "triggerByRelease")) {
-        ASSIGN_BOOL(Cfg.SecondaryRoles_AdvancedStrategyTriggerByRelease);
+        DEFINE_NONE_LIMITS();
+        ASSIGN_CUSTOM(int32_t, intVar, Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent, ConsumeSecondaryRoleTriggerByRelease(ctx, Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent));
     }
     else if (ConsumeToken(ctx, "triggerByPress")) {
-        ASSIGN_BOOL(Cfg.SecondaryRoles_AdvancedStrategyTriggerByPress);
+        DEFINE_NONE_LIMITS();
+        ASSIGN_CUSTOM(int32_t, intVar, Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent, ConsumeSecondaryRoleTriggerByPress(ctx, Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent));
+    }
+    else if (ConsumeToken(ctx, "triggeringEvent")) {
+        DEFINE_NONE_LIMITS();
+        ASSIGN_CUSTOM(int32_t, intVar, Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent, ConsumeSecondaryRoleTriggeringEvent(ctx));
     }
     else if (ConsumeToken(ctx, "triggerByMouse")) {
         ASSIGN_BOOL(Cfg.SecondaryRoles_AdvancedStrategyTriggerByMouse);
@@ -320,8 +326,8 @@ static macro_variable_t secondaryRoleAdvanced(parser_context_t* ctx, set_command
         DEFINE_INT_LIMITS(0, 255);
         ASSIGN_INT(Cfg.SecondaryRoles_AdvancedStrategyMinimumHoldTime);
     }
-    else if (ConsumeToken(ctx, "primaryFromSameHalf")) {
-        ASSIGN_BOOL(Cfg.SecondaryRoles_AdvancedStrategyPrimaryFromSameHalf);
+    else if (ConsumeToken(ctx, "acceptTriggersFromSameHalf")) {
+        ASSIGN_BOOL(Cfg.SecondaryRoles_AdvancedStrategyAcceptTriggersFromSameHalf);
     }
     else {
         Macros_ReportErrorTok(ctx, "Parameter not recognized:");
diff --git a/right/src/postponer.c b/right/src/postponer.c
index ddeb47ed9..6539baea5 100644
--- a/right/src/postponer.c
+++ b/right/src/postponer.c
@@ -398,35 +398,47 @@ void PostponerQuery_InfoByKeystate(key_state_t* key, postponer_buffer_record_typ
     }
 }
 
-void PostponerQuery_InfoByQueueIdx(uint8_t idx, postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release)
+void PostponerQuery_FindFirstPressed(postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release,
+                                     key_state_t *opposingKey)
 {
-    *press = NULL;
-    *release = NULL;
-    uint8_t startIdx = getPendingKeypressIdx(idx);
-    if(startIdx == 255) {
-        return;
-    }
-    *press = &buffer[POS(startIdx)];
-    for ( int i = startIdx; i < bufferSize; i++ ) {
-        postponer_buffer_record_type_t* rec = &buffer[POS(i)];
-        if (rec->event.type == PostponerEventType_ReleaseKey && rec->event.key.keyState == (*press)->event.key.keyState) {
-            *release = rec;
-            return;
+    bool opposingIsRight = KeyState_IsRightSide(opposingKey);
+    for ( int i = 0; i < bufferSize; i++ ) {
+        *press = &buffer[POS(i)];
+        if ((*press)->event.type == PostponerEventType_PressKey) {
+            if (opposingKey == NULL || opposingIsRight != KeyState_IsRightSide((*press)->event.key.keyState)) {
+                for ( int j = i + 1; j < bufferSize; j++ ) {
+                    *release = &buffer[POS(j)];
+                    if ((*release)->event.type == PostponerEventType_ReleaseKey
+                        && (*press)->event.key.keyState == (*release)->event.key.keyState ) {
+                        return;
+                    }
+                }
+                *release = NULL;
+                return;
+            }
         }
     }
+    *release = NULL;
+    *press = NULL;
+    return;
 }
 
-void PostponerQuery_FindFirstReleased(postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release)
+void PostponerQuery_FindFirstReleased(postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release,
+                                      key_state_t *opposingKey)
 {
+    bool opposingIsRight = KeyState_IsRightSide(opposingKey);
     if (bufferSize > 1) {
         for ( int i = 1; i < bufferSize; i++ ) {
             *release = &buffer[POS(i)];
             if ((*release)->event.type == PostponerEventType_ReleaseKey) {
-                for ( int j = 0; j < i; j++ ) {
-                    *press = &buffer[POS(j)];
-                    if((*press)->event.type == PostponerEventType_PressKey
-                        && (*press)->event.key.keyState == (*release)->event.key.keyState )
-                    return;
+                if (opposingKey == NULL || opposingIsRight != KeyState_IsRightSide((*release)->event.key.keyState)) {
+                    for ( int j = 0; j < i; j++ ) {
+                        *press = &buffer[POS(j)];
+                        if ((*press)->event.type == PostponerEventType_PressKey
+                            && (*press)->event.key.keyState == (*release)->event.key.keyState ) {
+                            return;
+                        }
+                    }
                 }
             }
         }
diff --git a/right/src/postponer.h b/right/src/postponer.h
index f86212f88..0ff44cefc 100644
--- a/right/src/postponer.h
+++ b/right/src/postponer.h
@@ -87,9 +87,9 @@
     bool PostponerQuery_IsKeyReleased(key_state_t* key);
     bool PostponerQuery_IsActiveEventually(key_state_t* key);
     void PostponerQuery_InfoByKeystate(key_state_t* key, postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release);
-    void PostponerQuery_InfoByQueueIdx(uint8_t idx, postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release);
-    void PostponerQuery_FindFirstReleased(postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release);
     bool PostponerQuery_ContainsKeyId(uint8_t keyid);
+    void PostponerQuery_FindFirstPressed(postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release, key_state_t* opposingKey);
+    void PostponerQuery_FindFirstReleased(postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release, key_state_t* opposingKey);
 
 // Functions (Query APIs extended):
     uint16_t PostponerExtended_PendingId(uint16_t idx);
diff --git a/right/src/secondary_role_driver.c b/right/src/secondary_role_driver.c
index 106d37d87..16d56fc91 100644
--- a/right/src/secondary_role_driver.c
+++ b/right/src/secondary_role_driver.c
@@ -27,7 +27,7 @@
  * Timeout strategy works mainly with key releases:
  *
  * - Secondary role is activated if timeout (i.e., Timeout) is reached.
- * - Secondary role is activated if action key is pressed and released within the span of press of the dual role key. (If triggerByRelease is active.)
+ * - Secondary role is activated if action key is pressed and released within the span of press of the dual role key. (If triggeringEvent is Release.)
  * - Long hold of primary action can be achieved by doubletapping the key. (If doubletapActivatedPrimary is active.)
  *
  * Configuration params:
@@ -35,9 +35,11 @@
  * - Timeout configures the basic timeout of the dual-role key.
  * - TimeoutAction - after Timeout, the key is defaulted to timeoutAction. Typically to secondary role.
  * - SafetyMargin decreases probability of unintentional secondary role, by offsetting release time of the keys by the amount.
- * - TriggerByRelease - if set to false, the only way to trigger secondary role is to press it for more than Timeout.
+ * - TriggeringEvent - dictates which action key action, if any, will trigger secondary role
  * - DoubletapTime - if dual-role key is tapped and press within this time (press-to-press), then primary role is activated.
  * - DoubletapToPrimary - if set to false, doubletap logic is disabled. Useful if you prefer tap and hold evaluate to primary role.
+ * - MinimumHoldTime - The minimum time that a key must be held for in order to allow it to trigger as secondary.
+ * - AcceptTriggersFromSameHalf - Whether or not action keys can be from the same half as the resolution key.
  *
  * This yields two most basic activation modes:
  *
@@ -47,7 +49,7 @@
  *   - Recommended params:
  *     - Timeout = 200
  *     - SafetyMargin = 0
- *     - TriggerByRelease = false
+ *     - TriggeringEvent = None
  *
  * - Via release order. Triggered mainly by correct release sequence.
  *   - Pros: is more reliable in suppressing unwanted secondary role activations.
@@ -55,11 +57,11 @@
  *   - Recommended params:
  *     - Timeout = 350
  *     - SafetyMargin = 50
- *     - TriggerByRelease = true
+ *     - TriggeringEvent = Release
  */
 
 static bool resolutionCallerIsMacroEngine = false;
-static bool primaryFromSameHalf = false;
+static bool acceptTriggersFromSameHalf = true;
 static key_state_t *resolutionKey;
 static uint32_t resolutionStartTime;
 
@@ -100,18 +102,18 @@ static secondary_role_state_t resolveCurrentKeyRoleIfDontKnowTimeout()
     //gather data
     postponer_buffer_record_type_t *dummy;
     postponer_buffer_record_type_t *dualRoleRelease;
-    postponer_buffer_record_type_t *actionPress;
+    postponer_buffer_record_type_t *actionPress = NULL;
     postponer_buffer_record_type_t *actionRelease;
+    key_state_t* opposingKey = acceptTriggersFromSameHalf ? NULL : resolutionKey;
 
     PostponerQuery_InfoByKeystate(resolutionKey, &dummy, &dualRoleRelease);
-    if (Cfg.SecondaryRoles_AdvancedStrategyTriggerByRelease) {
-        PostponerQuery_FindFirstReleased(&actionPress, &actionRelease);
+    if (Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent == SecondaryRoleTriggeringEvent_Release) {
+        PostponerQuery_FindFirstReleased(&actionPress, &actionRelease, opposingKey);
+        
     }
-    if (!Cfg.SecondaryRoles_AdvancedStrategyTriggerByRelease || actionPress == NULL) {
-        PostponerQuery_InfoByQueueIdx(0, &actionPress, &actionRelease);
+    if (Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent != SecondaryRoleTriggeringEvent_None && actionPress == NULL) {
+        PostponerQuery_FindFirstPressed(&actionPress, &actionRelease, opposingKey);
     }
-    uint16_t actionKeyId = actionPress != NULL ? Utils_KeyStateToKeyId(actionPress->event.key.keyState) : 255;
-    uint16_t dualRoleId = Utils_KeyStateToKeyId(resolutionKey);
 
     int32_t activeTime = (dualRoleRelease == NULL ? Timer_GetCurrentTime() : dualRoleRelease->time) - resolutionStartTime;
     bool dualRoleWasHeldLongEnoughToBeAllowedSecondary = activeTime >= Cfg.SecondaryRoles_AdvancedStrategyMinimumHoldTime;
@@ -159,14 +161,7 @@ static secondary_role_state_t resolveCurrentKeyRoleIfDontKnowTimeout()
     }
 
     //handle trigger by press
-    if (Cfg.SecondaryRoles_AdvancedStrategyTriggerByPress) {
-        bool actionKeyWasPressedAndFromTheSameHalf = primaryFromSameHalf && actionPress != NULL && Utils_AreKeysOnTheSameHalf(actionKeyId, dualRoleId);
-
-        if (actionKeyWasPressedAndFromTheSameHalf) {
-            KEY_TIMING(KeyTiming_RecordComment(resolutionKey, "PE"));
-            return SecondaryRoleState_Primary;
-        }
-        
+    if (Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent == SecondaryRoleTriggeringEvent_Press) {
         bool actionKeyWasPressedButDualkeyNot = actionPress != NULL && dualRoleRelease == NULL && (int32_t)(Timer_GetCurrentTime() - actionPress->time) > Cfg.SecondaryRoles_AdvancedStrategySafetyMargin;
         bool actionKeyWasPressedFirst = actionPress != NULL && dualRoleRelease != NULL && actionPress->time <= dualRoleRelease->time - Cfg.SecondaryRoles_AdvancedStrategySafetyMargin;
 
@@ -190,14 +185,7 @@ static secondary_role_state_t resolveCurrentKeyRoleIfDontKnowTimeout()
     }
 
     //handle trigger by release
-    if (Cfg.SecondaryRoles_AdvancedStrategyTriggerByRelease) {
-        bool actionKeyWasReleasedAndFromSameHalf = primaryFromSameHalf && actionRelease != NULL && Utils_AreKeysOnTheSameHalf(actionKeyId, dualRoleId);
-        
-        if (actionKeyWasReleasedAndFromSameHalf) {
-            KEY_TIMING(KeyTiming_RecordComment(resolutionKey, "PH"));
-            return SecondaryRoleState_Primary;
-        }
-
+    if (Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent == SecondaryRoleTriggeringEvent_Release) {
         bool actionKeyWasReleasedButDualkeyNot = actionRelease != NULL && (dualRoleRelease == NULL && (int32_t)(Timer_GetCurrentTime() - actionRelease->time) > Cfg.SecondaryRoles_AdvancedStrategySafetyMargin);
         bool actionKeyWasReleasedFirst = actionRelease != NULL && dualRoleRelease != NULL && actionRelease->time <= dualRoleRelease->time - Cfg.SecondaryRoles_AdvancedStrategySafetyMargin;
 
@@ -220,7 +208,7 @@ static secondary_role_state_t resolveCurrentKeyRoleIfDontKnowTimeout()
         }
     }
 
-    bool triggerBehaviorsActive = Cfg.SecondaryRoles_AdvancedStrategyTriggerByRelease || Cfg.SecondaryRoles_AdvancedStrategyTriggerByPress;
+    bool triggerBehaviorsActive = Cfg.SecondaryRoles_AdvancedStrategyTriggeringEvent != SecondaryRoleTriggeringEvent_None;
 
     // handle timeout when action key is pressed
     if (activeTime >= Cfg.SecondaryRoles_AdvancedStrategyTimeout) {
@@ -281,14 +269,14 @@ static void startResolution(
     resolutionStartTime = CurrentPostponedTime;
     resolutionCallerIsMacroEngine = isMacroResolution;
     switch (actionFromSameHalf) {
-        case SecondaryRole_PrimaryFromSameHalf:
-            primaryFromSameHalf = true;
+        case SecondaryRole_AcceptTriggersFromSameHalf:
+            acceptTriggersFromSameHalf = true;
             break;
-        case SecondaryRole_PrimaryFromSameHalfDisabled:
-            primaryFromSameHalf = false;
+        case SecondaryRole_IgnoreTriggersFromSameHalf:
+            acceptTriggersFromSameHalf = false;
             break;
         default:
-            primaryFromSameHalf = Cfg.SecondaryRoles_AdvancedStrategyPrimaryFromSameHalf;
+            acceptTriggersFromSameHalf = Cfg.SecondaryRoles_AdvancedStrategyAcceptTriggersFromSameHalf;
             break;
     }
 
diff --git a/right/src/secondary_role_driver.h b/right/src/secondary_role_driver.h
index 39bff91dc..3b719e898 100644
--- a/right/src/secondary_role_driver.h
+++ b/right/src/secondary_role_driver.h
@@ -64,10 +64,16 @@
 
     typedef enum {
         SecondaryRole_DefaultFromSameHalf,
-        SecondaryRole_PrimaryFromSameHalf,
-        SecondaryRole_PrimaryFromSameHalfDisabled,
+        SecondaryRole_IgnoreTriggersFromSameHalf,
+        SecondaryRole_AcceptTriggersFromSameHalf,
     } secondary_role_same_half_t;
 
+    typedef enum {
+        SecondaryRoleTriggeringEvent_None,
+        SecondaryRoleTriggeringEvent_Press,
+        SecondaryRoleTriggeringEvent_Release,
+    } secondary_role_triggering_event_t;
+
 // Variables:
 
 // Functions:
diff --git a/right/src/str_utils.c b/right/src/str_utils.c
index aaefda11f..48213b282 100644
--- a/right/src/str_utils.c
+++ b/right/src/str_utils.c
@@ -475,6 +475,55 @@ secondary_role_state_t ConsumeSecondaryRoleTimeoutAction(parser_context_t* ctx)
     }
 }
 
+secondary_role_triggering_event_t ConsumeSecondaryRoleTriggeringEvent(parser_context_t* ctx)
+{
+    if (ConsumeToken(ctx, "press")) {
+        return SecondaryRoleTriggeringEvent_Press;
+    }
+    else if (ConsumeToken(ctx, "release")) {
+        return SecondaryRoleTriggeringEvent_Release;
+    }
+    else if (ConsumeToken(ctx, "none")) {
+        return SecondaryRoleTriggeringEvent_None;
+    }
+    else {
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
+        return SecondaryRoleTriggeringEvent_Press;
+    }
+}
+
+secondary_role_triggering_event_t ConsumeSecondaryRoleTriggerByPress(parser_context_t* ctx, secondary_role_triggering_event_t current)
+{
+    bool triggerByPress = Macros_ConsumeBool(ctx);
+    if ( triggerByPress ) {
+        return SecondaryRoleTriggeringEvent_Press;
+    }
+    switch ( current ) {
+        case SecondaryRoleTriggeringEvent_Press:
+        case SecondaryRoleTriggeringEvent_None:
+            return SecondaryRoleTriggeringEvent_None;
+        case SecondaryRoleTriggeringEvent_Release:
+        default:
+            return SecondaryRoleTriggeringEvent_Release;
+    }
+}
+
+secondary_role_triggering_event_t ConsumeSecondaryRoleTriggerByRelease(parser_context_t* ctx, secondary_role_triggering_event_t current)
+{
+    bool triggerByRelease = Macros_ConsumeBool(ctx);
+    if ( triggerByRelease ) {
+        return SecondaryRoleTriggeringEvent_Release;
+    }
+    switch ( current ) {
+        case SecondaryRoleTriggeringEvent_Release:
+        case SecondaryRoleTriggeringEvent_None:
+            return SecondaryRoleTriggeringEvent_None;
+        case SecondaryRoleTriggeringEvent_Press:
+        default:
+            return SecondaryRoleTriggeringEvent_Press;
+    }
+}
+
 secondary_role_strategy_t ConsumeSecondaryRoleStrategy(parser_context_t* ctx)
 {
     if (ConsumeToken(ctx, "simple")) {
diff --git a/right/src/str_utils.h b/right/src/str_utils.h
index 4f27fc052..82614f432 100644
--- a/right/src/str_utils.h
+++ b/right/src/str_utils.h
@@ -87,6 +87,9 @@
     const char* TokEnd(const char* cmd, const char *cmdEnd);
     module_id_t ConsumeModuleId(parser_context_t* ctx);
     secondary_role_state_t ConsumeSecondaryRoleTimeoutAction(parser_context_t* ctx);
+    secondary_role_triggering_event_t ConsumeSecondaryRoleTriggeringEvent(parser_context_t* ctx);
+    secondary_role_triggering_event_t ConsumeSecondaryRoleTriggerByPress(parser_context_t* ctx, secondary_role_triggering_event_t current);
+    secondary_role_triggering_event_t ConsumeSecondaryRoleTriggerByRelease(parser_context_t* ctx, secondary_role_triggering_event_t current);
     secondary_role_strategy_t ConsumeSecondaryRoleStrategy(parser_context_t* ctx);
     navigation_mode_t ConsumeNavigationModeId(parser_context_t* ctx);
     const char* DeviceModelName(device_id_t device);
diff --git a/right/src/utils.c b/right/src/utils.c
index f4e60452a..8b5f9b923 100644
--- a/right/src/utils.c
+++ b/right/src/utils.c
@@ -182,13 +182,3 @@ bool ShouldResendReport(bool statusOk, uint8_t* counter) {
         return false;
     }
 }
-
-static uint8_t isRightHalfOrModule(uint16_t id)
-{
-    return id < 64 || id >= 192;
-}
-
-bool Utils_AreKeysOnTheSameHalf(uint16_t oneKey, uint16_t anotherKey)
-{
-    return isRightHalfOrModule(oneKey) == isRightHalfOrModule(anotherKey);
-}
diff --git a/right/src/utils.h b/right/src/utils.h
index ec4fe4083..0a6e79e78 100644
--- a/right/src/utils.h
+++ b/right/src/utils.h
@@ -43,7 +43,6 @@ if (reentrancyGuard_active) {                    \
     uint16_t Utils_KeyCoordinatesToKeyId(uint8_t slotId, uint8_t keyIdx);
     const char* Utils_KeyAbbreviation(key_state_t* keyState);
     bool ShouldResendReport(bool statusOk, uint8_t* counter);
-    bool Utils_AreKeysOnTheSameHalf(uint16_t oneKey, uint16_t anotherKey);
 
 
 #endif /* SRC_UTILS_H_ */