OK. More testing done. I've hit a condition where the dependency scan in the last build still isn't hitting absolutely everything. Another build coming soon...

@therealdb said in [Reactor] Variables not updating correctly in latest-25201-2aa18550:

OMG, very old rules, isn't it? Thanks, I fixed it.

This particular effort has made me look at rules that I haven't touched since the earliest days as well, many of them almost untouched copies from the Vera importer. It's a trip down memory lane, for sure, and a follow-on "wow, there's such a better way to do that now".

How's the latest working out so far? @tunnus have you had a chance to play with it as well?

@therealdb said in [Reactor] Variables not updating correctly in latest-25201-2aa18550:

[latest-25248]2025-09-11T07:19:37.603Z Rule:ERR Full expression: t = time(), m = dateparts(t).month, d = dateparts(t).day,
(m == 12 && d == 24) ||
(m == 12 && d == 25) ||
(m == 12 && d == 31) ||
(m == 1 && d == 1) ||
(m == 1 && d == 5) ||
(m == 1 && d == 6)

Just a tip, a more efficient way to write this:

parts = dateparts(), m=parts.month, d=parts.day,
    (m == 12 && d == 24) ||
    (m == 12 && d == 25) ||
    (m == 12 && d == 31) ||
    (m == 1 && d == 1) ||
    (m == 1 && d == 5) ||
    (m == 1 && d == 6)

The default time for dateparts() is the current time, so you don't need d, and by saving dateparts() to parts, the function is only invoked once. We old-timers love to save every cycle we squeeze out of the processor!

New build latest-25254 posted. This should address the local variable in rule-based expressions at startup issue. Docker 64-bit platforms only.

OK. Yes, the new build also has some new error reporting. That message was probably being logged, but since you weren't looking at the logs, you didn't see it.

You can also combine those into one status test, which will be a good bit more efficient:

- id: groups
  enabled: true
  implementation: DynamicGroupController
  name: Dynamic Group Controller
  config:
    groups:
      zwavejs_dead:
        select:
          - include_group: zwavejs
        filter_expression: <
          entity?.attributes?.zwave_device?.status === 3 ||
          entity?.attributes?.zwave_device?.status_text === "dead"

Also, please... Please... PLEASE do not screen shot pure text. Use the fenced code block formatting here for text like expressions, configs, logs, etc. It may be expeditious for you to just paste the screen shot, but when I try to give you suggestions or corrections like the above, I have to retype the entire block (I can't copy-paste the text and update it). That not only takes a bunch of time, but also introduces the possibility that I will make a typo in the part we don't care about and leave you with a non-working example we then need to fix in yet another series of post replies.

Don't forget to remove the Rule logging when it isn't needed.

Is there a global variable called dead (it's not shown above)?

Or are you looking for the word dead in status_text? Because if it's that, your expression is incorrectly formed.

OK. Interim build latest-25248 for 64-bit docker systems only is up for testing/trials.

NOTE TO ALL USERS NOT CONTRIBUTING TO THIS THREAD — this is not an official build and you are advised not to upgrade to it just yet. This build is specifically for participants in this thread as we work to improve the behavior of Rule-based variables. Wait for a build advertised in the official announcement thread before upgrading your system.

Behavior of Rule-based variables now:

• Will still be re-evaluated when the Rule is started, and any time the Rule is subject to trigger condition check (i.e. behavior not changed);
• When the trigger condition check occurs, Rule-based variables are always evaluated/updated before trigger conditions (i.e. also same as before);
• Rule-based variables may be modified by Set Variable action and assignment statements in Script Actions in Rule Reactions (unreliable before);
• If a Rule-based variable references another Rule-based variable, and the latter changes, the former will be re-evaluated (now same as Global Variables).
• The order of Rule-based variables doesn't matter, it's just for your convenience. Dependencies between variables are established at startup, and evaluation takes place in dependency tree order, not the order shown in the UI (now same as Global Variables).

If you run into an issue you can't resolve, here's what I ask:

1. Make sure your expectations are aligned with the changes above; make sure you are not relying on any prior behavior or side-effect of the prior behavior.

2. Enable logging for the rule in question. Put a snippet like below in your logging.yaml file (replace the part after # with your rule ID):

    "Rule#rule-l3hj06aa":
      level: 5
      streams:
      - type: file  # filename is derived from rule ID
        keep: 2
        level: 999
        recycle: true
   

3. Restart Reactor and get the rule in question to demonstrate whatever the issue is. Make sure to then capture the log file called Logger#Rule#XXX.log... I will be asking for it.

4. Report the issue here on this thread, with all of the usual attention to posting requirements: good, detailed description; expectations of behavior; clear description of what's not meeting expectations; etc.

5. I will PM you a URL where you can upload the log file and your rule JSON file (from storage/rules) if necessary.

The locally-installed version of the documentation is also updated.

It's probably moot at this point... I've just spent the last two weeks completely revamping the evaluation of Rule-based variables, to make them perform more like global variables, respect dependencies between them better, etc. The last week has just been a deep dive through the logs watching the performance of my own house on the updated approach.

I'll shortly be releasing a blind build with these changes, just for you (@tunnus) and @therealdb to try. I expect this to be disruptive, because any approaches in the logic that rely on specific behaviors and side-effects of the old approach will now work differently, maybe fail, and adapting to the new approach will be necessary. But, I think the new approach will produce a result that is much more in keeping with how you would expect it to work. So, sit tight... I'll be ready to build later today or early tomorrow.

This looks like a job for a finite state machine.

An alternate way to tackle this may be to have a state local variable that's just a number/counter that increments when the scene controller button is pushed... Set Variable state = ${{ ( ( state ?#0 } + 1 ) % 3 }}. This will make state cycle through the values 0, 1, 2, 0, 1, 2...

Then the reaction has these groups:

• When state == 0: turn both fans off
• When state == 1: turn 1 on, 2 off
• When state == 2: turn 1 off, 2 on

It's easy to add a fourth state if you want the option of having both fans on at the same time. I'll leave the changes as an exercise for readers. DM if you need a hint.

This is not something i'm going to entertain at the moment. It seems like a very specialized, one-off request, and the implementation has a lot of consequences throughout the system. I recommend starting and stopping using the currently available method (i.e. stopping the process itself). It's also relatively easy to enable and disable rules in the UI, so when working on isolated systems (like a heating/AC unit), you can temporarily disable just those rules. You can also force them to a set or reset state to keep them at bay, and put them back in auto later.

It works as I would predict.

@CatmanV2 said in Expose MSR entities:

@toggledbits this is precisely what it is, yes

Whew. OK. Then yes, this is the way to go.

@CatmanV2 said in Expose MSR entities:

Currently I am using the owntracks_sensor for tracking phones being in region in HA and it works great.

I'm reading this as "it's coming from HA."

Is it actually an MQTT entity created using the owntracks_in_region template of MQTTController? Because there's nothing natively called owntracks_sensor in Reactor.

I am still completely confused. Yes, Reactor will publish the sensor from HA. I use that myself. But since the Reactor sensor entity comes from HA, why would want to publish Reactor's entity back to HA then?

I'll say again, local variables are not processed/evaluated in the same way as global variables. Local variables are only evaluated when the Rule to which they belong is being evaluated (i.e. its triggers are being checked). They are not evaluated when a dependent local variable is changed. When the Rule is evaluated, its local variables, if any, are evaluated before the triggers, and yes, they are evaluated in the order in which they are defined. That is known.

Combine this with using a Set Variable action... if you don't check the "Force re-evaluation" checkbox, any other local variables that use the variable being set will not be updated until the Rule is next evaluated. If you check the box, it forces a Rule evaluation, and it is the second evaluation that will update the dependent variables.

The Script Action is absolutely relevant in your case, at least from what you've posted, because you apparently still had local variables that are dependent on the local variable that the script was changing, and that was not consistent with my recommendation. The script will not cause the dependent variables to be updated, because there is no "Force re-evaluation" option for the script, and local variables are not dependency-scanned/triggered, as I said above. That means your script action will change the local variable ok_to_reset, but that won't make peak_power change immediately after. That is why I recommended that you make all local variables expressionless when using the Script Action, and do all of the work in the script, none of the work in the local variables' expressions.

None of this is new. And again, no changes have been made to how variables (global or local) in any of these recent builds. The earlier changes you mentioned to make isRuleSet() and isRuleEnabled() trigger with the rules they reference (build 25082 -- a long time ago) was a change to the implementation of those functions themselves , but was not in any way a change to the mechanism that handles changes in global expressions.

@CatmanV2 said in Expose MSR entities:

Apologies if the ask is not clear/

Yeah, sorry. It's not at all clear to me what you're asking here. I'm reading "I have an owntracks_sensor in Home Assistant... is there any way to expose that sensor (which comes from Home Assistant) to Home Assistant trivially?" Uh... what?

Post your script. Based on the instructions given, your local variables should be expressionless, so that seems wrong and I want to see what your script is trying to do.

I can tell you right now, if ok_to_reset is expressionless and you are resetting it in the Script Action script, and expecting peak_power to see the updated value, it won't work.

@tunnus said in [Reactor] Variables not updating correctly in latest-25201-2aa18550:

I was wondering if this could happen in cases where re-evaluation is queued but somehow gets stuck, and because new requests are ignored, updates won't occur?

Well, they won't get stuck, but there is no guaranteed order to the re-evaluation. Other things waiting to execute can run before the re-evaluation happens, including things that could change the global variables or entity attributes on which the first Rule depends.

Here's something to try (it's the @therealdb solution he mentioned):

1. Make msg an expressionless local variable.
2. Before your notification, use a Set Variable or Script Action to compute the value of msg that you want to send in the notification.

Would look something like this:

...or this, using a Script Action...

I personally prefer the Script Action because you can set several variables at once in the script, if that's what you need, and the syntax looks cleaner (you don't have to use the ${{ }} substitution.

Basically it sounds like you just want Reactor to stop, so why not just stop it?

I'd need a full picture of this... every variable and rule involved. This is a very complex area to look at.

Again, the key rule to understand here, is that the local variables in a Rule do not update every time a global or other local they refer to changes -- they only update when the Rule has been marked for evaluation. The recomputation of the local variable values occurs before trigger conditions are evaluated, and only then. That is very different from the way global variables are handled.

Also in your second example, the use of "==" is a "loose" comparison. The use of "===" is tighter and matches type. In your example, if success is 0 (numeric), that will satisfy the test success == false -- that's true because numeric 0 will cast to boolean false, so they are logically equal, although not exactly equal. That alone would explain unexpected results, if the values of success can be other than true or false.