@@ -39,7 +39,7 @@ The following ASCII characters are forbidden in **Model Names** and **Port Names
 ### Port Name
 - **Cannot be empty**
 - **Cannot start with a digit**
-- **Cannot be a reserved attribute**: `ID`, `name`, `_description`, `_skipIf`, `_successIf`, `_failureIf`, `_while`, `_onSuccess`, `_onFailure`, `_onHalted`, `_post`, `_autoremap`, `__shared_blackboard`
+- **Cannot be a reserved attribute**: `ID`, `name`, `_description`, `_skipIf`, `_successIf`, `_failureIf`, `_while`, `_onlyIf`, `_onStart`, `_onSuccess`, `_onFailure`, `_onHalted`, `_post`, `_autoremap`, `__shared_blackboard`
 - No forbidden characters (see table above)
 
 ### Instance Name
 
@@ -14,6 +14,8 @@ Pre-conditions are evaluated **before** a node's `tick()` method is called. They
 | `_successIf` | IDLE only | If true, return SUCCESS without calling tick() |
 | `_skipIf` | IDLE only | If true, return SKIPPED without calling tick() |
 | `_while` | IDLE and RUNNING | If false when IDLE, return SKIPPED. If false when RUNNING, halt node and return SKIPPED |
+| `_onlyIf` | IDLE only | If false, return SKIPPED without calling tick() (the opposite of `_skipIf`) |
+| `_onStart` | IDLE only | Not a condition: execute the script right before the first tick() |
 
 ### Evaluation Order
 
@@ -22,12 +24,16 @@ When a node has multiple pre-conditions, they are evaluated in this order:
 2. `_successIf`
 3. `_skipIf`
 4. `_while`
+5. `_onlyIf`
+6. `_onStart`
 
-The first condition that triggers will determine the result.
+The first condition that triggers will determine the result. `_onStart` comes last,
+so its script is executed only if no other pre-condition has short-circuited the node.
+If both `_skipIf` and `_onlyIf` are present, either one can skip the node.
 
 ### Important: One-time Evaluation
 
-**`_failureIf`, `_successIf`, and `_skipIf` are evaluated only once** when the node transitions from IDLE (or SKIPPED) to another state. They are **NOT re-evaluated** while the node is RUNNING.
+**`_failureIf`, `_successIf`, `_skipIf`, `_onlyIf` and `_onStart` are evaluated only once** when the node transitions from IDLE (or SKIPPED) to another state. They are **NOT re-evaluated** while the node is RUNNING.
 
 This means if you have:
 ```xml
@@ -48,10 +54,25 @@ If `battery_ok` becomes false while `MyAction` is running, the action is interru
 
 ### When to Use Each Pre-condition
 
-- **`_skipIf`**: Skip a node without failing the parent (useful in Sequences)
+- **`_skipIf`** / **`_onlyIf`**: Skip a node without failing the parent (useful in Sequences)
 - **`_failureIf`**: Fail early based on a condition (useful in Fallbacks)
 - **`_successIf`**: Succeed early based on a condition
 - **`_while`**: Guard that must remain true for the entire execution
+- **`_onStart`**: Initialize or reset blackboard entries when the node starts,
+  e.g. `<MyAction _onStart="attempts := 0"/>`
+
+### Notes on `_onStart`
+
+- It runs **every time the node starts from IDLE**, not once per tree execution. Inside a
+  `Retry` or `Repeat`, the child goes back to IDLE after each iteration, so
+  `_onStart="attempts := 0"` is re-executed on every iteration.
+  Likewise, a node placed before a RUNNING sibling in a `ReactiveSequence` is halted and
+  re-ticked from IDLE on every tick, so its `_onStart` runs on every tick.
+- It runs just before `tick()`, but a pre-tick callback (see `setPreTickFunction()`, used for
+  instance by Groot2 breakpoints and status injection) may still substitute the result after
+  `_onStart` has run, in which case `tick()` is not called.
+- `ThreadedAction` does not evaluate any pre-condition, `_onlyIf` and `_onStart` included:
+  it runs `tick()` in its own thread, bypassing the pre/post-condition checks.
 
 ### The `<Precondition>` Decorator
 
 
@@ -48,9 +48,9 @@ using NonPortAttributes = std::unordered_map<std::string, std::string>;
  * @brief Pre-conditions that can be attached to any node via XML attributes.
  *
  * Pre-conditions are evaluated in the order defined by this enum (FAILURE_IF first,
- * then SUCCESS_IF, then SKIP_IF, then WHILE_TRUE).
+ * then SUCCESS_IF, SKIP_IF, WHILE_TRUE, ONLY_IF and finally ON_START).
  *
- * **Important**: FAILURE_IF, SUCCESS_IF, and SKIP_IF are evaluated **only once**
+ * **Important**: all of them except WHILE_TRUE are evaluated **only once**
  * when the node transitions from IDLE (or SKIPPED) to another state.
  * They are NOT re-evaluated while the node is RUNNING.
  *
@@ -62,6 +62,11 @@ using NonPortAttributes = std::unordered_map<std::string, std::string>;
  *   If false when IDLE, return SKIPPED. If false when RUNNING, halt the node
  *   and return SKIPPED. This is the only pre-condition that can interrupt
  *   a running node.
+ * - `_onlyIf="<script>"`: If false when node is IDLE, return SKIPPED immediately
+ *   (the opposite of `_skipIf`).
+ * - `_onStart="<script>"`: Not a condition: the script is executed right before
+ *   the first tick() of the node, i.e. only if none of the pre-conditions above
+ *   returned a status.
  *
  * If you need a condition to be re-evaluated on every tick, use the
  * `<Precondition>` decorator node with `else="RUNNING"` instead of these attributes.
@@ -72,12 +77,17 @@ enum class PreCond
   SUCCESS_IF,
   SKIP_IF,
   WHILE_TRUE,
+  // new values are appended to the end to preserve ABI
+  ONLY_IF,
+  ON_START,
   COUNT_
 };
 
-static const std::array<std::string, 4> PreCondNames = {  //
-  "_failureIf", "_successIf", "_skipIf", "_while"
+static const std::array<std::string, 6> PreCondNames = {  //
+  "_failureIf", "_successIf", "_skipIf", "_while", "_onlyIf", "_onStart"
 };
+static_assert(PreCondNames.size() == size_t(PreCond::COUNT_),
+              "PreCondNames must have one entry per PreCond");
 
 enum class PostCond
 {
@@ -92,6 +102,8 @@ enum class PostCond
 static const std::array<std::string, 4> PostCondNames = {  //
   "_onHalted", "_onFailure", "_onSuccess", "_post"
 };
+static_assert(PostCondNames.size() == size_t(PostCond::COUNT_),
+              "PostCondNames must have one entry per PostCond");
 
 template <>
 [[nodiscard]] std::string toStr<BT::PostCond>(const BT::PostCond& cond);
 
@@ -215,8 +215,8 @@ Expected<NodeStatus> TreeNode::checkPreConditions()
 {
   Ast::Environment env = { config().blackboard, config().enums };
 
-  // Check pre-conditions in order: FAILURE_IF, SUCCESS_IF, SKIP_IF, WHILE_TRUE.
-  // IMPORTANT: _failureIf, _successIf, and _skipIf are evaluated ONLY when the
+  // Check pre-conditions in the order of the PreCond enum.
+  // IMPORTANT: all of them, except _while, are evaluated ONLY when the
   // node is IDLE or SKIPPED. They are NOT re-evaluated while the node is RUNNING.
   for(size_t index = 0; index < size_t(PreCond::COUNT_); index++)
   {
@@ -227,31 +227,45 @@ Expected<NodeStatus> TreeNode::checkPreConditions()
     }
 
     const auto preID = static_cast<PreCond>(index);
+    auto is_true = [&]() { return parse_executor(env).cast<bool>(); };
 
-    // _failureIf, _successIf, _skipIf: only checked when IDLE or SKIPPED
     // _while: checked here AND also when RUNNING (see below)
     if(_p->status == NodeStatus::IDLE || _p->status == NodeStatus::SKIPPED)
     {
-      // what to do if the condition is true
-      if(parse_executor(env).cast<bool>())
+      switch(preID)
       {
-        if(preID == PreCond::FAILURE_IF)
-        {
-          return NodeStatus::FAILURE;
-        }
-        if(preID == PreCond::SUCCESS_IF)
-        {
-          return NodeStatus::SUCCESS;
-        }
-        if(preID == PreCond::SKIP_IF)
-        {
-          return NodeStatus::SKIPPED;
-        }
-      }
-      // if the conditions is false
-      else if(preID == PreCond::WHILE_TRUE)
-      {
-        return NodeStatus::SKIPPED;
+        case PreCond::FAILURE_IF:
+          if(is_true())
+          {
+            return NodeStatus::FAILURE;
+          }
+          break;
+        case PreCond::SUCCESS_IF:
+          if(is_true())
+          {
+            return NodeStatus::SUCCESS;
+          }
+          break;
+        case PreCond::SKIP_IF:
+          if(is_true())
+          {
+            return NodeStatus::SKIPPED;
+          }
+          break;
+        case PreCond::WHILE_TRUE:
+        case PreCond::ONLY_IF:
+          if(!is_true())
+          {
+            return NodeStatus::SKIPPED;
+          }
+          break;
+        case PreCond::ON_START:
+          // the last one: no precondition returned a status, so the node proceeds
+          // to tick(). A pre-tick callback (e.g. Groot2) may still substitute the result.
+          parse_executor(env);
+          break;
+        case PreCond::COUNT_:
+          break;
       }
     }
     else if(_p->status == NodeStatus::RUNNING && preID == PreCond::WHILE_TRUE)
 
@@ -1648,6 +1648,8 @@ std::string writeTreeXSD(const BehaviorTreeFactory& factory)
     </xs:complexType>
     <xs:attributeGroup name="preconditionAttributeGroup">
       <xs:attribute name="_failureIf" type="xs:string" use="optional"/>
+      <xs:attribute name="_onlyIf" type="xs:string" use="optional"/>
+      <xs:attribute name="_onStart" type="xs:string" use="optional"/>
       <xs:attribute name="_skipIf" type="xs:string" use="optional"/>
       <xs:attribute name="_successIf" type="xs:string" use="optional"/>
       <xs:attribute name="_while" type="xs:string" use="optional"/>