The solution I came up with for a similar situation was to use an external system to throttle the activation and to use two separate rules.
TLDR:
I have the first Hubitat rule make a http request that triggers a Node Red flow. The Node Red flow receives the http requests from the Hubitat, passes them to a trigger node that only allows one message through every couple seconds, and then makes a http request back to a http enpoint on the Hubitat to trigger the second rule. No matter how many times the first rule triggers during that time period, only one callback to the endpoint will be made.
The Node Red flow looks like this:
The first node in the flow sets up the listener on "http://[node-red-ip]:1880/debounce". You can send parameters in the request like "http://[node-red-ip]:1880/debounce?a=1&b=2". In Node Red you can then refer to those parameters as msg.req.query.a, msg.req.query.b, etc. So the first Hubitat rule makes a request and passes the endpoint of the second rule as a request parameter.
To use this I first set up the action rule (the second rule) with a single trigger event of "http endpoint". I always copy that endpoint and paste it into the rule notes so I can find it later. Now that I have the endpoint URL, I can set up the first rule.
For example, if the endpoint is "http://[hubitat_ip]/apps/api/1234/trigger?access_token=xxxxxxxx-edd5-447b-b2d4-xxxxxxxxxxxx"...
The first rule with multiple triggers will have an action to send the following 'http get':
"http://[node-red-ip]:1880/debounce?callback=1234/trigger?access_token=xxxxxxxx-edd5-447b-b2d4-xxxxxxxxxxxx
This calls the Node Red listener and passes a query parameter of "callback" that contains the last part of the endpoint URL. In Node Red that is stored in the msg.req.query.callback variable.
The next node is a throttle node that will only pass one message every two seconds for any given msg.req.query.callback. That means multiple rules can call different endpoints multiple times in the same two seconds and the throttle node will pass one message for each endpoint. It can be set to pass the first or last message. I have it set to pass the last (most recent) message at the end of the 2-second delay.
The function node just sets up the outbound request by appending the 'callback' string onto the first part of the endpoint URL with the following code:
msg.url='http://[hubitat_ip]/apps/api/'
msg.url += msg.req.query.callback
return msg;
So this creates the full endpoint URL from the query that was received. The last node calls that URL, triggering the second rule on the Hubitat.
I'm using this to send notifications when my car's tire pressures are low. The trigger on the first rule is for any of the 4 tires being below a threshold. Often when it gets cold overnight, all 4 of them report low at the same instant the next time the car is moved. With this method, I get only a single notification when that happens.
IIRC I tried to use one rule calling a virtual switch which triggered another rule to accomplish the same thing completely in Hubitat, but even when I used a virtual switch, the system was seeing the virtual switch turn on more than once when the triggers went off in rapid succession.
IDRC (I do remember correctly). Here it is: Preventing double/concurrent activation - #7 by bravenel
At the end of that thread Bruce posted a link to some Groovy code that could be modified to do this entirely on the Hubitat. At the time I wasn't comfortable trying to modify Groovy and I was already using Node Red for other things, so I went the Node-Red route.
