From 36e32ead8db34970cdba5e5f98762cf007fd17c7 Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Fri, 30 Jan 2026 19:06:32 +0100
Subject: [PATCH 01/11] Fix #1029: correct left-associativity for arithmetic
 operators in script parser

The scripting engine evaluated "A - B + C" as "A - (B + C)" instead of
"(A - B) + C". The root cause was that string_concat's operand chain
referenced math_sum, causing it to appear twice in lexy's operation list
with conflicting binding power levels. Changed string_concat::operand
from math_sum to math_prefix to eliminate the duplicate entry.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../behaviortree_cpp/scripting/operators.hpp  |  5 ++-
 tests/script_parser_test.cpp                  | 36 +++++++++++++++++++
 2 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/include/behaviortree_cpp/scripting/operators.hpp b/include/behaviortree_cpp/scripting/operators.hpp
index bd6bfc863..7df8af4d0 100644
--- a/include/behaviortree_cpp/scripting/operators.hpp
+++ b/include/behaviortree_cpp/scripting/operators.hpp
@@ -747,7 +747,10 @@ struct Expression : lexy::expression_production
       return dsl::op<Ast::ExprBinaryArithmetic::concat>(LEXY_LIT(".."));
     }();
 
-    using operand = math_sum;
+    // Use math_prefix (not math_sum) to avoid duplicating math_sum/math_product
+    // in the operation list, which would break left-associativity of +/-/*//
+    // due to conflicting binding power levels in lexy's _operation_list_of.
+    using operand = math_prefix;
   };
 
   // ~x
diff --git a/tests/script_parser_test.cpp b/tests/script_parser_test.cpp
index bc9346dd4..a0823a981 100644
--- a/tests/script_parser_test.cpp
+++ b/tests/script_parser_test.cpp
@@ -424,6 +424,42 @@ TEST(ParserTest, Issue595)
   ASSERT_EQ(0, counters[0]);
 }
 
+// https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1029
+TEST(ParserTest, OperatorAssociativity_Issue1029)
+{
+  BT::Ast::Environment environment = { BT::Blackboard::create(), {} };
+
+  auto GetResult = [&environment](const char* text) -> BT::Any {
+    return GetScriptResult(environment, text);
+  };
+
+  // Addition and subtraction are left-associative:
+  // "5 - 2 + 1" should be (5-2)+1 = 4, NOT 5-(2+1) = 2
+  EXPECT_EQ(GetResult("5 - 2 + 1").cast<double>(), 4.0);
+
+  // "10 - 3 - 2" should be (10-3)-2 = 5, NOT 10-(3-2) = 9
+  EXPECT_EQ(GetResult("10 - 3 - 2").cast<double>(), 5.0);
+
+  // "2 + 3 - 1" should be (2+3)-1 = 4
+  EXPECT_EQ(GetResult("2 + 3 - 1").cast<double>(), 4.0);
+
+  // Multiplication and division are also left-associative:
+  // "12 / 3 / 2" should be (12/3)/2 = 2, NOT 12/(3/2) = 8
+  EXPECT_EQ(GetResult("12 / 3 / 2").cast<double>(), 2.0);
+
+  // "12 / 3 * 2" should be (12/3)*2 = 8, NOT 12/(3*2) = 2
+  EXPECT_EQ(GetResult("12 / 3 * 2").cast<double>(), 8.0);
+
+  // Mixed precedence: "2 + 3 * 4 - 1" should be 2+(3*4)-1 = 13
+  EXPECT_EQ(GetResult("2 + 3 * 4 - 1").cast<double>(), 13.0);
+
+  // Verify string concatenation operator (..) still works after operand fix
+  EXPECT_EQ(GetResult("A:='hello'; B:=' world'; A .. B").cast<std::string>(), "hello "
+                                                                              "world");
+  // Chained concatenation (left-associative)
+  EXPECT_EQ(GetResult("A .. ' ' .. B").cast<std::string>(), "hello  world");
+}
+
 TEST(ParserTest, NewLine)
 {
   BT::BehaviorTreeFactory factory;

From 498af67af8096bd75c55447af5656857c200d081 Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Fri, 30 Jan 2026 19:42:03 +0100
Subject: [PATCH 02/11] Add regression test for #923: ValidateScript OOB read
 with large invalid scripts

The bug (fixed in cb6c751) was that ValidateScript used a fixed char[2048]
buffer for error messages, causing out-of-bounds reads when error output
exceeded the buffer. The current code uses std::string with
std::back_inserter. This adds a regression test using the original
reproducer to ensure the fix holds.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 tests/script_parser_test.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/tests/script_parser_test.cpp b/tests/script_parser_test.cpp
index a0823a981..fccb6b3ce 100644
--- a/tests/script_parser_test.cpp
+++ b/tests/script_parser_test.cpp
@@ -460,6 +460,30 @@ TEST(ParserTest, OperatorAssociativity_Issue1029)
   EXPECT_EQ(GetResult("A .. ' ' .. B").cast<std::string>(), "hello  world");
 }
 
+// https://github.com/BehaviorTree/BehaviorTree.CPP/issues/923
+// Regression test: ValidateScript must not crash on large invalid scripts
+// that produce error messages exceeding any fixed-size buffer.
+TEST(ParserTest, ValidateScriptLargeError_Issue923)
+{
+  // Build an invalid script large enough to overflow the old 2048-byte buffer
+  std::string script;
+  for(int i = 0; i < 10; i++)
+  {
+    script += "+6e66>6666.6+66\r6>6;6e62=6+6e66>66666'; en';o';o'; en'; ";
+    script += "\x7f"
+              "n"
+              "\x7f"
+              "r;6.6+66.H>6+6"
+              "\x80"
+              "6"
+              "\x1e"
+              ";@e66";
+  }
+  // Must not crash (old code used a fixed char[2048] buffer causing OOB read)
+  auto result = BT::ValidateScript(script);
+  EXPECT_FALSE(result);  // invalid script, but no crash
+}
+
 TEST(ParserTest, NewLine)
 {
   BT::BehaviorTreeFactory factory;

From d0aeddab133b87e2045ba445cbe4a29f487b4d28 Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Fri, 30 Jan 2026 19:43:49 +0100
Subject: [PATCH 03/11] Add regression test for #832: script compare with
 negative number

Comparing against negative literals (e.g., "A!=-1") used to throw
"operator cannot be mixed with previous operators" because the unary
minus prefix was in a conflicting operator group. This was resolved by
the #1029 fix (string_concat operand change). This commit adds a
regression test covering both direct script evaluation and XML
precondition usage.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 tests/script_parser_test.cpp | 38 ++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/tests/script_parser_test.cpp b/tests/script_parser_test.cpp
index fccb6b3ce..4b9dd5212 100644
--- a/tests/script_parser_test.cpp
+++ b/tests/script_parser_test.cpp
@@ -460,6 +460,44 @@ TEST(ParserTest, OperatorAssociativity_Issue1029)
   EXPECT_EQ(GetResult("A .. ' ' .. B").cast<std::string>(), "hello  world");
 }
 
+// https://github.com/BehaviorTree/BehaviorTree.CPP/issues/832
+TEST(ParserTest, CompareWithNegativeNumber_Issue832)
+{
+  BT::Ast::Environment environment = { BT::Blackboard::create(), {} };
+
+  auto GetResult = [&environment](const char* text) -> BT::Any {
+    return GetScriptResult(environment, text);
+  };
+
+  // "A != -1" should parse and evaluate correctly
+  EXPECT_EQ(GetResult("A:=0; A!=-1").cast<int>(), 1);   // 0 != -1 is true
+  EXPECT_EQ(GetResult("A:=-1; A!=-1").cast<int>(), 0);  // -1 != -1 is false
+  EXPECT_EQ(GetResult("A:=0; A==-1").cast<int>(), 0);   // 0 == -1 is false
+  EXPECT_EQ(GetResult("A:=0; A>-1").cast<int>(), 1);    // 0 > -1 is true
+  EXPECT_EQ(GetResult("A:=0; A<-1").cast<int>(), 0);    // 0 < -1 is false
+
+  // Also test that ValidateScript accepts these expressions
+  EXPECT_TRUE(BT::ValidateScript("A:=0; A!=-1"));
+  EXPECT_TRUE(BT::ValidateScript("A:=0; A>-1"));
+
+  // Reproducer from the issue: precondition with negative literal
+  BT::BehaviorTreeFactory factory;
+  const std::string xml_text = R"(
+  <root BTCPP_format="4">
+      <BehaviorTree>
+         <Sequence>
+             <Script code=" A:=0 " />
+             <AlwaysSuccess _failureIf="A!=-1"/>
+         </Sequence>
+      </BehaviorTree>
+  </root>
+  )";
+  auto tree = factory.createTreeFromText(xml_text);
+  // A==0, so A!=-1 is true, meaning _failureIf triggers => FAILURE
+  auto status = tree.tickWhileRunning();
+  EXPECT_EQ(status, BT::NodeStatus::FAILURE);
+}
+
 // https://github.com/BehaviorTree/BehaviorTree.CPP/issues/923
 // Regression test: ValidateScript must not crash on large invalid scripts
 // that produce error messages exceeding any fixed-size buffer.

From 6f68ed64b9cdc26f947de0b52d7d4d1e6efb745a Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Fri, 30 Jan 2026 19:57:19 +0100
Subject: [PATCH 04/11] Fix #1065: upgrade weakly-typed blackboard entries from
 subtree string remapping

When a SubTree passes a constant string literal (e.g., queue="1;2;3") to a
child tree's port, the subtree remapping stores it as a plain std::string in
the child blackboard without type information. Later, when a strongly-typed
node like LoopDouble reads the entry, Any::cast<SharedQueue<double>>() fails
because there's no conversion path from string to the expected type.

Fix: in createNodeFromXML, when initializing port entries, detect when an
existing blackboard entry is weakly typed but the port manifest declares a
strong type. In this case, convert the string value using the port's
parseString() method and upgrade the entry's type info in place.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/xml_parsing.cpp   | 25 ++++++++++++++++
 tests/gtest_ports.cpp | 66 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 91 insertions(+)

diff --git a/src/xml_parsing.cpp b/src/xml_parsing.cpp
index a11383041..b257c6b4a 100644
--- a/src/xml_parsing.cpp
+++ b/src/xml_parsing.cpp
@@ -929,6 +929,31 @@ TreeNode::Ptr XMLParser::PImpl::createNodeFromXML(const XMLElement* element,
                                demangle(prev_info->type()), "] and, later type [",
                                demangle(port_info.type()), "] was used somewhere else.");
           }
+
+          // If the existing entry is not strongly typed (e.g. set as a plain
+          // string from subtree remapping) but the port IS strongly typed,
+          // upgrade the entry by converting the string value. Issue #1065.
+          if(!prev_info->isStronglyTyped() && port_info.isStronglyTyped())
+          {
+            auto entry = blackboard->getEntry(port_key);
+            if(entry)
+            {
+              std::scoped_lock lock(entry->entry_mutex);
+              if(!entry->value.empty() && entry->value.isString())
+              {
+                auto str_val = entry->value.tryCast<std::string>();
+                if(str_val)
+                {
+                  auto typed_val = port_info.parseString(*str_val);
+                  if(!typed_val.empty())
+                  {
+                    entry->info = port_info;
+                    entry->value = typed_val;
+                  }
+                }
+              }
+            }
+          }
         }
         else
         {
diff --git a/tests/gtest_ports.cpp b/tests/gtest_ports.cpp
index bd02bd7dc..a3e64c3b3 100644
--- a/tests/gtest_ports.cpp
+++ b/tests/gtest_ports.cpp
@@ -581,3 +581,69 @@ TEST(PortTest, DefaultWronglyOverriden)
   // This is correct
   ASSERT_NO_THROW(auto tree = factory.createTreeFromText(xml_txt_correct));
 }
+
+// Issue #1065: passing a string literal like "1;2;3" through a SubTree port
+// to a LoopDouble node should work, but fails because the subtree remapping
+// stores the value as a plain std::string in the blackboard without converting
+// it to SharedQueue<double>.
+class CollectDoubleAction : public SyncActionNode
+{
+public:
+  CollectDoubleAction(const std::string& name, const NodeConfig& config,
+                      std::vector<double>* collected)
+    : SyncActionNode(name, config), collected_(collected)
+  {}
+
+  NodeStatus tick() override
+  {
+    double val = 0;
+    if(getInput("value", val))
+    {
+      collected_->push_back(val);
+      return NodeStatus::SUCCESS;
+    }
+    return NodeStatus::FAILURE;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::InputPort<double>("value") };
+  }
+
+private:
+  std::vector<double>* collected_;
+};
+
+TEST(PortTest, SubtreeStringLiteralToLoopDouble_Issue1065)
+{
+  // The main tree passes a string literal "1;2;3" to the subtree port "queue".
+  // Inside the subtree, LoopDouble should parse it and iterate over the values.
+  std::string xml_txt = R"(
+    <root BTCPP_format="4">
+      <BehaviorTree ID="MainTree">
+        <SubTree ID="LoopSubTree" queue="1;2;3" />
+      </BehaviorTree>
+
+      <BehaviorTree ID="LoopSubTree">
+        <LoopDouble queue="{queue}" value="{number}">
+          <CollectDouble value="{number}" />
+        </LoopDouble>
+      </BehaviorTree>
+    </root>
+  )";
+
+  std::vector<double> collected;
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<CollectDoubleAction>("CollectDouble", &collected);
+  factory.registerBehaviorTreeFromText(xml_txt);
+
+  auto tree = factory.createTree("MainTree");
+  auto status = tree.tickWhileRunning();
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+  ASSERT_EQ(collected.size(), 3u);
+  EXPECT_DOUBLE_EQ(collected[0], 1.0);
+  EXPECT_DOUBLE_EQ(collected[1], 2.0);
+  EXPECT_DOUBLE_EQ(collected[2], 3.0);
+}

From a0286a06c190b914ff9793709353ee42b9cff886 Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Sat, 31 Jan 2026 01:13:40 +0100
Subject: [PATCH 05/11] Fix #982: handle json: prefix in vector
 convertFromString specializations

When a port of type std::vector<T> has a default empty value {} and no
input is specified in XML, toStr() converts the empty vector to "json:[]".
The explicit convertFromString specializations for vector types did not
handle the "json:" prefix (unlike the generic template), so this string
was split by ';' producing a vector with one literal "json:[]" element.

Fix: add "json:" prefix detection at the top of all four vector
convertFromString specializations (int, double, bool, string). When
detected, parse directly with nlohmann::json instead of splitting by ';'.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/basic_types.cpp   | 20 +++++++++++++++
 tests/gtest_ports.cpp | 57 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 77 insertions(+)

diff --git a/src/basic_types.cpp b/src/basic_types.cpp
index 284e2eb77..714247b5e 100644
--- a/src/basic_types.cpp
+++ b/src/basic_types.cpp
@@ -222,6 +222,11 @@ float convertFromString<float>(StringView str)
 template <>
 std::vector<int> convertFromString<std::vector<int>>(StringView str)
 {
+  if(StartWith(str, "json:"))
+  {
+    str.remove_prefix(5);
+    return nlohmann::json::parse(str).get<std::vector<int>>();
+  }
   auto parts = splitString(str, ';');
   std::vector<int> output;
   output.reserve(parts.size());
@@ -235,6 +240,11 @@ std::vector<int> convertFromString<std::vector<int>>(StringView str)
 template <>
 std::vector<double> convertFromString<std::vector<double>>(StringView str)
 {
+  if(StartWith(str, "json:"))
+  {
+    str.remove_prefix(5);
+    return nlohmann::json::parse(str).get<std::vector<double>>();
+  }
   auto parts = splitString(str, ';');
   std::vector<double> output;
   output.reserve(parts.size());
@@ -248,6 +258,11 @@ std::vector<double> convertFromString<std::vector<double>>(StringView str)
 template <>
 std::vector<bool> convertFromString<std::vector<bool>>(StringView str)
 {
+  if(StartWith(str, "json:"))
+  {
+    str.remove_prefix(5);
+    return nlohmann::json::parse(str).get<std::vector<bool>>();
+  }
   auto parts = splitString(str, ';');
   std::vector<bool> output;
   output.reserve(parts.size());
@@ -261,6 +276,11 @@ std::vector<bool> convertFromString<std::vector<bool>>(StringView str)
 template <>
 std::vector<std::string> convertFromString<std::vector<std::string>>(StringView str)
 {
+  if(StartWith(str, "json:"))
+  {
+    str.remove_prefix(5);
+    return nlohmann::json::parse(str).get<std::vector<std::string>>();
+  }
   auto parts = splitString(str, ';');
   std::vector<std::string> output;
   output.reserve(parts.size());
diff --git a/tests/gtest_ports.cpp b/tests/gtest_ports.cpp
index a3e64c3b3..809a06d52 100644
--- a/tests/gtest_ports.cpp
+++ b/tests/gtest_ports.cpp
@@ -647,3 +647,60 @@ TEST(PortTest, SubtreeStringLiteralToLoopDouble_Issue1065)
   EXPECT_DOUBLE_EQ(collected[1], 2.0);
   EXPECT_DOUBLE_EQ(collected[2], 3.0);
 }
+
+// Issue #982: A port of type std::vector<std::string> with a default empty value {}
+// gets initialized with the literal string "json:[]" instead of being empty.
+// This happens because toStr() converts {} to "json:[]", and the vector
+// convertFromString specialization doesn't handle the "json:" prefix.
+class ActionWithDefaultEmptyVector : public SyncActionNode
+{
+public:
+  ActionWithDefaultEmptyVector(const std::string& name, const NodeConfig& config,
+                               std::vector<std::string>* out_vec)
+    : SyncActionNode(name, config), out_vec_(out_vec)
+  {}
+
+  NodeStatus tick() override
+  {
+    if(!getInput("string_vector", *out_vec_))
+    {
+      return NodeStatus::FAILURE;
+    }
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::InputPort<std::vector<std::string>>("string_vector", {},
+                                                     "A string vector") };
+  }
+
+private:
+  std::vector<std::string>* out_vec_;
+};
+
+TEST(PortTest, DefaultEmptyVector_Issue982)
+{
+  // Port has default value {} (empty vector) and no input specified in XML.
+  // The vector should be empty, not contain "json:[]".
+  std::string xml_txt = R"(
+    <root BTCPP_format="4">
+      <BehaviorTree ID="MainTree">
+        <ActionWithDefaultEmptyVector />
+      </BehaviorTree>
+    </root>
+  )";
+
+  std::vector<std::string> result;
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<ActionWithDefaultEmptyVector>("ActionWithDefaultEmptyVector",
+                                                         &result);
+  auto tree = factory.createTreeFromText(xml_txt);
+  auto status = tree.tickWhileRunning();
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+  ASSERT_TRUE(result.empty()) << "Expected empty vector, but got " << result.size()
+                              << " element(s). First element: \""
+                              << (result.empty() ? "" : result[0]) << "\"";
+}

From a2f6a86b53562e55527428f2ec8668ab5250d996 Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Sat, 31 Jan 2026 09:02:09 +0100
Subject: [PATCH 06/11] Fix #969: LoopNode accepts std::vector<T> in addition
 to SharedQueue<T>

LoopNode's queue port now uses an untyped BidirectionalPort to avoid
port type mismatch when upstream nodes produce std::vector<T>. At
runtime, tick() tries SharedQueue<T> first, then falls back to
std::vector<T> (converted to deque on first read), then string
(via convertFromString). This allows upstream nodes that output
vector<T> to feed directly into LoopNode without manual conversion.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 FIXME.md                                      | 259 ++++++++++++++++++
 .../behaviortree_cpp/decorators/loop_node.h   |  38 ++-
 tests/gtest_ports.cpp                         |  55 ++++
 3 files changed, 349 insertions(+), 3 deletions(-)
 create mode 100644 FIXME.md

diff --git a/FIXME.md b/FIXME.md
new file mode 100644
index 000000000..cc92226cc
--- /dev/null
+++ b/FIXME.md
@@ -0,0 +1,259 @@
+# FIXME - Bug Tracker
+
+This file tracks reported bugs from GitHub issues. For each bug, the workflow is:
+1. Write a unit test that reproduces the issue
+2. Evaluate whether the behavior diverges from intended library semantics
+3. Fix the issue (if confirmed as a bug)
+
+---
+
+## Scripting / Script Parser
+
+### [x] #1029 - Mathematical order of operations in script is wrong
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1029
+- **Summary:** `A - B + C` is evaluated as `A - (B + C)` instead of left-to-right. The expression parser applies incorrect associativity for addition and subtraction at the same precedence level.
+- **Component:** `src/scripting/`
+- **Test file:** `tests/gtest_scripting.cpp` (or new)
+
+### [x] #923 - Out-of-bounds read in script validation
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/923
+- **Summary:** `ValidateScript` can create a `std::string` from a non-NULL-terminated fixed-size stack buffer when parsing invalid scripts that generate large error messages, causing `strlen` to read out of bounds.
+- **Component:** `src/scripting/`
+- **Test file:** `tests/gtest_scripting.cpp` (or new)
+
+### [x] #832 - Script compare with negative number throws exception
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/832
+- **Summary:** Using a negative number in a script precondition (e.g., `_failureIf="A!=-1"`) throws a runtime exception. The scripting parser cannot handle negative number literals in comparisons.
+- **Component:** `src/scripting/`
+- **Test file:** `tests/gtest_scripting.cpp` (or new)
+
+---
+
+## Ports / Type Conversion
+
+### [x] #1065 - Type conversion problem with subtree
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1065
+- **Summary:** Passing a `std::deque<double>` through a SubTree port via a string literal (e.g., `"1;2;3"`) throws `std::runtime_error` about no safe conversion between `std::string` and `std::shared_ptr<std::deque<double>>`. String-to-deque conversion fails at subtree boundary.
+- **Component:** `src/xml_parsing.cpp`, `include/behaviortree_cpp/basic_types.h`
+- **Test file:** `tests/gtest_ports.cpp` (or new)
+
+### [x] #982 - Vectors initialized with `json:[]` string instead of empty
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/982
+- **Summary:** When a port of type `std::vector<std::string>` has a default empty value `{}` and no input is specified in XML, the vector is initialized with the literal string `"json:[]"` instead of being an empty vector.
+- **Component:** `include/behaviortree_cpp/basic_types.h`, `src/xml_parsing.cpp`
+- **Test file:** `tests/gtest_ports.cpp`
+
+### [x] #969 - LoopNode: std::vector<T> vs std::deque<T> type mismatch
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/969
+- **Summary:** `LoopNode<T>` uses `std::shared_ptr<std::deque<T>>` for its queue port, but upstream nodes often produce `std::vector<T>`. This creates a port type conflict during tree creation.
+- **Component:** `include/behaviortree_cpp/decorators/loop_node.h`
+- **Test file:** `tests/gtest_decorator.cpp` (or new)
+
+### [ ] #948 - ParseString errors with custom enum types
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/948
+- **Summary:** `parseString` in `tree_node.h` has an unsafe `find` on an unordered_map that may not be instantiated yet if `getInput` is called during construction. Also, custom enum types cannot be properly parsed via `convertFromString`.
+- **Component:** `include/behaviortree_cpp/tree_node.h`, `include/behaviortree_cpp/basic_types.h`
+- **Test file:** `tests/gtest_ports.cpp`
+
+### [ ] #858 - getInput throws when default parameter is passed
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/858
+- **Summary:** Calling `getInput` with a default parameter value throws `std::out_of_range` (`_Map_base::at`). The internal map lookup fails when the port has a default value but the entry does not exist in the expected location.
+- **Component:** `include/behaviortree_cpp/tree_node.h`
+- **Test file:** `tests/gtest_ports.cpp`
+
+---
+
+## Blackboard
+
+### [ ] #974 - Blackboard set() stores values as string type
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/974
+- **Summary:** When using `blackboard->set(key, value.dump())` to set numeric values from JSON, the blackboard stores them as strings. Subsequent scripting operations with numeric operators fail because string types cannot be compared numerically.
+- **Component:** `src/blackboard.cpp`, `include/behaviortree_cpp/blackboard.h`
+- **Test file:** `tests/gtest_blackboard.cpp`
+
+### [ ] #942 - Default blackboard entry not created for locked content
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/942
+- **Summary:** When using `getLockedPortContent` on a port with a default blackboard entry, no blackboard entry is actually created on the first call. The returned `AnyPtrLocked` is a default/empty value not placed into the blackboard.
+- **Component:** `src/blackboard.cpp`, `include/behaviortree_cpp/blackboard.h`
+- **Test file:** `tests/gtest_blackboard.cpp`
+
+### [ ] #408 - debugMessage does not print parent values in SubTree
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/408
+- **Summary:** `config().blackboard->debugMessage()` inside a SubTree node's constructor does not show remapped entries from the parent blackboard. The function only checks `internal_to_external_` after finding an entry in `storage_`.
+- **Component:** `src/blackboard.cpp`
+- **Test file:** `tests/gtest_blackboard.cpp`
+
+---
+
+## Control Nodes (Parallel)
+
+### [ ] #1045 - Test PauseWithRetry is flaky
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1045
+- **Summary:** The `Parallel.PauseWithRetry` test fails intermittently due to tight timing assertions. Measured time drifts beyond the allowed margin.
+- **Component:** `tests/gtest_parallel.cpp`
+- **Test file:** `tests/gtest_parallel.cpp`
+
+### [ ] #1041 - Performance degradation after prolonged operation in parallel nodes
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1041
+- **Summary:** After prolonged operation, when a parallel node's child detects an exception and exits, the interval before other nodes wait for execution becomes increasingly longer. Likely related to resource accumulation or thread management.
+- **Component:** `src/controls/parallel_node.cpp`
+- **Test file:** `tests/gtest_parallel.cpp` (or new)
+
+### [ ] #966 - ParallelAll max_failures off-by-one semantics
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/966
+- **Summary:** `ParallelAll` documents `max_failures` as "if the number of children returning FAILURE *exceeds* this value" but implements `>=` (greater-than-or-equal). Documentation and implementation disagree.
+- **Component:** `src/controls/parallel_all_node.cpp`
+- **Test file:** `tests/gtest_parallel.cpp`
+
+---
+
+## Control Nodes (Reactive)
+
+### [ ] #1031 - Race condition in ReactiveSequence/ReactiveFallback with async children
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1031
+- **Summary:** With backchaining patterns, a previously `RUNNING` child is halted only *after* another child's `onStart` is executed. Two children are in `RUNNING` state simultaneously briefly, causing race conditions.
+- **Component:** `src/controls/reactive_sequence.cpp`, `src/controls/reactive_fallback.cpp`
+- **Test file:** `tests/gtest_reactive.cpp` (or new)
+
+### [ ] #917 - Precondition not re-checked in ReactiveSequence
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/917
+- **Summary:** When a node has a `_successIf` precondition inside a `ReactiveSequence`, the precondition is never re-evaluated after the node enters `RUNNING` state. The node continues returning `RUNNING` instead of `SUCCESS`.
+- **Component:** `src/controls/reactive_sequence.cpp`, `src/tree_node.cpp`
+- **Test file:** `tests/gtest_reactive.cpp`
+
+---
+
+## XML Parsing
+
+### [ ] #979 - Recursive behavior trees cause stack overflow
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/979
+- **Summary:** A behavior tree can reference its own ID as a SubTree, causing infinite recursion and stack overflow during XML parsing. The parser does not detect or prevent cyclic subtree references.
+- **Component:** `src/xml_parsing.cpp`
+- **Test file:** `tests/gtest_factory.cpp` (or new)
+
+### [ ] #883 - JSON string in port value interpreted as blackboard reference
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/883
+- **Summary:** Setting a port value to a JSON string in XML (e.g., `settings='{{"a": 0.8}}'`) causes `{}` content to be interpreted as blackboard variable references instead of literal JSON.
+- **Component:** `src/xml_parsing.cpp`, `src/tree_node.cpp`
+- **Test file:** `tests/gtest_factory.cpp` (or new)
+
+### [ ] #880 - External subtree from file not found when loaded via inline XML
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/880
+- **Summary:** When a subtree is registered via `registerBehaviorTreeFromFile()` and then referenced from inline XML via `createTreeFromText()`, the factory throws `"Can't find a tree with name: MyTree"`.
+- **Component:** `src/xml_parsing.cpp`, `src/bt_factory.cpp`
+- **Test file:** `tests/gtest_factory.cpp`
+
+### [ ] #672 - Stack buffer overflow in xml_parsing.cpp
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/672
+- **Summary:** AddressSanitizer detects a stack-buffer-overflow in `xml_parsing.cpp` when parsing certain XML tree definitions. Memory safety issue in the XML parser.
+- **Component:** `src/xml_parsing.cpp`
+- **Test file:** `tests/gtest_factory.cpp` (or new)
+
+---
+
+## BehaviorTreeFactory
+
+### [ ] #1046 - Heap use-after-free when factory is destroyed before ticking
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1046
+- **Summary:** If `BehaviorTreeFactory` is destroyed before its created tree is ticked, `NodeConfig` holds a dangling pointer to `TreeNodeManifest` owned by the factory. Accessing it causes heap-use-after-free.
+- **Component:** `src/bt_factory.cpp`, `include/behaviortree_cpp/tree_node.h`
+- **Test file:** `tests/gtest_factory.cpp`
+
+### [ ] #937 - BehaviorTreeFactory cannot be returned by value
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/937
+- **Summary:** Making `BehaviorTreeFactory` non-copyable also inadvertently prevents returning it by value from functions. Some compilers do not apply guaranteed copy elision in all contexts.
+- **Component:** `include/behaviortree_cpp/bt_factory.h`
+- **Test file:** `tests/gtest_factory.cpp` (or new)
+
+### [ ] #934 - Segfault when substituting subtree
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/934
+- **Summary:** `factory.loadSubstitutionRuleFromJSON()` followed by `factory.createTree()` causes a segmentation fault when the substitution target is a subtree node.
+- **Component:** `src/bt_factory.cpp`
+- **Test file:** `tests/gtest_factory.cpp`
+
+### [ ] #930 - Mock substitution with registerSimpleAction causes tree to hang
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/930
+- **Summary:** When using mock node substitution rules with `registerSimpleAction()`, the behavior tree gets stuck after an async delay finishes. The substituted node does not behave like the original.
+- **Component:** `src/bt_factory.cpp`
+- **Test file:** `tests/gtest_factory.cpp` (or new)
+
+---
+
+## Loggers
+
+### [ ] #1057 - Groot2Publisher enters infinite loop on exception
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/1057
+- **Summary:** `Groot2Publisher` can enter an infinite loop during destruction. When `active_server` is set to `false`, it can be reset to `true` depending on timing, causing `server_thread.join()` to hang indefinitely.
+- **Component:** `src/loggers/groot2_publisher.cpp`
+- **Test file:** New test needed
+
+---
+
+## Tree Execution
+
+### [ ] #686 - haltTree doesn't effectively halt tickWhileRunning
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/686
+- **Summary:** `haltTree()` resets tree status to `IDLE`, which only breaks the inner loop of `tickRoot`. The outer loop then restarts execution because `IDLE` satisfies its condition, so the tree is never truly halted with `tickWhileRunning()`.
+- **Component:** `src/bt_factory.cpp`, `include/behaviortree_cpp/bt_factory.h`
+- **Test file:** `tests/gtest_tree.cpp` (or new)
+
+---
+
+## TreeNode
+
+### [ ] #861 - Tick time monitoring can measure 0 due to instruction reordering
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/861
+- **Summary:** The `std::chrono` calls around `executeTick()` in `tree_node.cpp` can be reordered by the compiler, resulting in a measured tick duration of 0.
+- **Component:** `src/tree_node.cpp`
+- **Test file:** `tests/gtest_tree.cpp` (or new)
+
+---
+
+## JSON Exporter
+
+### [ ] #989 - JsonExporter throws during vector conversion
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/989
+- **Summary:** A `bad_function_call` exception is thrown when converting `std::vector` types to JSON via `JsonExporter`. The conversion function is not properly registered for vector types.
+- **Component:** `include/behaviortree_cpp/json_export.h`
+- **Test file:** New test needed
+
+---
+
+## Build / Dependencies
+
+### [ ] #959 - Version conflict with embedded nlohmann::json causes UB
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/959
+- **Summary:** The library embeds `nlohmann::json` v3.11.3 in its headers. If the user's codebase uses a different version, ODR violations occur depending on header include order, potentially causing undefined behavior.
+- **Component:** `3rdparty/`, `CMakeLists.txt`
+- **Test file:** Build system test / CMake configuration
+
+---
+
+## Platform-Specific
+
+### [ ] #869 - Read access violation on Windows debug build
+- **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/869
+- **Summary:** Running on VS 2022 in Debug mode causes a read access violation in string hashing within the library DLL. Release mode works fine, suggesting a debug-mode-specific memory issue.
+- **Component:** Core library (platform-specific)
+- **Test file:** Requires Windows environment
+
+---
+
+## Summary
+
+| Category | Count | Issue Numbers |
+|----------|-------|---------------|
+| Scripting / Script Parser | 3 | #1029, #923, #832 |
+| Ports / Type Conversion | 5 | #1065, #982, #969, #948, #858 |
+| Blackboard | 3 | #974, #942, #408 |
+| Control Nodes (Parallel) | 3 | #1045, #1041, #966 |
+| Control Nodes (Reactive) | 2 | #1031, #917 |
+| XML Parsing | 4 | #979, #883, #880, #672 |
+| BehaviorTreeFactory | 4 | #1046, #937, #934, #930 |
+| Loggers | 1 | #1057 |
+| Tree Execution | 1 | #686 |
+| TreeNode | 1 | #861 |
+| JSON Exporter | 1 | #989 |
+| Build / Dependencies | 1 | #959 |
+| Platform-Specific | 1 | #869 |
+| **Total** | **30** | |
diff --git a/include/behaviortree_cpp/decorators/loop_node.h b/include/behaviortree_cpp/decorators/loop_node.h
index 71a032b10..de06d0165 100644
--- a/include/behaviortree_cpp/decorators/loop_node.h
+++ b/include/behaviortree_cpp/decorators/loop_node.h
@@ -15,6 +15,7 @@
 #include "behaviortree_cpp/decorator_node.h"
 
 #include <deque>
+#include <vector>
 
 namespace BT
 {
@@ -75,7 +76,37 @@ class LoopNode : public DecoratorNode
           static_queue_ ? AnyPtrLocked() : getLockedPortContent("queue");
       if(any_ref)
       {
-        current_queue_ = any_ref.get()->cast<SharedQueue<T>>();
+        // Try SharedQueue<T> first, then fall back to std::vector<T>.
+        // This allows upstream nodes that output vector<T> to be used
+        // directly with LoopNode without manual conversion. Issue #969.
+        auto queue_result = any_ref.get()->tryCast<SharedQueue<T>>();
+        if(queue_result)
+        {
+          current_queue_ = queue_result.value();
+        }
+        else if(!current_queue_)
+        {
+          // Only convert on first read; after that, use the
+          // already-converted current_queue_ (which gets popped).
+          auto vec_result = any_ref.get()->tryCast<std::vector<T>>();
+          if(vec_result)
+          {
+            // Accept std::vector<T> from upstream nodes. Issue #969.
+            const auto& vec = vec_result.value();
+            current_queue_ = std::make_shared<std::deque<T>>(vec.begin(), vec.end());
+          }
+          else if(any_ref.get()->isString())
+          {
+            // Accept string values (e.g. from subtree remapping). Issue #1065.
+            auto str = any_ref.get()->cast<std::string>();
+            current_queue_ = convertFromString<SharedQueue<T>>(str);
+          }
+          else
+          {
+            throw RuntimeError("LoopNode: port 'queue' must contain either "
+                               "SharedQueue<T>, std::vector<T>, or a string");
+          }
+        }
       }
 
       if(current_queue_ && !current_queue_->empty())
@@ -114,8 +145,9 @@ class LoopNode : public DecoratorNode
 
   static PortsList providedPorts()
   {
-    // we mark "queue" as BidirectionalPort, because the original element is modified
-    return { BidirectionalPort<SharedQueue<T>>("queue"),
+    // Use an untyped BidirectionalPort to accept both SharedQueue<T>
+    // and std::vector<T> without triggering a port type mismatch. Issue #969.
+    return { BidirectionalPort("queue"),
              InputPort<NodeStatus>("if_empty", NodeStatus::SUCCESS,
                                    "Status to return if queue is empty: "
                                    "SUCCESS, FAILURE, SKIPPED"),
diff --git a/tests/gtest_ports.cpp b/tests/gtest_ports.cpp
index 809a06d52..81a5731a1 100644
--- a/tests/gtest_ports.cpp
+++ b/tests/gtest_ports.cpp
@@ -704,3 +704,58 @@ TEST(PortTest, DefaultEmptyVector_Issue982)
                               << " element(s). First element: \""
                               << (result.empty() ? "" : result[0]) << "\"";
 }
+
+// Issue #969: LoopNode<T> uses SharedQueue<T> (shared_ptr<deque<T>>) for its queue
+// port, but upstream nodes often produce std::vector<T>. This type mismatch causes
+// tree creation to fail.
+class ProduceVectorDoubleAction : public SyncActionNode
+{
+public:
+  ProduceVectorDoubleAction(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    std::vector<double> vec = { 10.0, 20.0, 30.0 };
+    setOutput("numbers", vec);
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BT::OutputPort<std::vector<double>>("numbers") };
+  }
+};
+
+TEST(PortTest, LoopNodeAcceptsVector_Issue969)
+{
+  // An upstream node outputs std::vector<double>, and LoopDouble should be
+  // able to iterate over it without requiring manual conversion to SharedQueue.
+  std::string xml_txt = R"(
+    <root BTCPP_format="4">
+      <BehaviorTree ID="MainTree">
+        <Sequence>
+          <ProduceVectorDouble numbers="{nums}" />
+          <LoopDouble queue="{nums}" value="{val}">
+            <CollectDouble value="{val}" />
+          </LoopDouble>
+        </Sequence>
+      </BehaviorTree>
+    </root>
+  )";
+
+  std::vector<double> collected;
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<ProduceVectorDoubleAction>("ProduceVectorDouble");
+  factory.registerNodeType<CollectDoubleAction>("CollectDouble", &collected);
+  auto tree = factory.createTreeFromText(xml_txt);
+  auto status = tree.tickWhileRunning();
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+  ASSERT_EQ(collected.size(), 3u);
+  EXPECT_DOUBLE_EQ(collected[0], 10.0);
+  EXPECT_DOUBLE_EQ(collected[1], 20.0);
+  EXPECT_DOUBLE_EQ(collected[2], 30.0);
+}

From 59fccffc5746d23f7a8e6fda6d7b1813ab772cbb Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Sat, 31 Jan 2026 09:11:20 +0100
Subject: [PATCH 07/11] Fix #948: parseString supports enums with
 convertFromString specializations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

parseString<T>() had two bugs for enum types:
1. Null pointer dereference on config().enums when getInput() was called
   before the factory assigned the scripting enum registry.
2. Enums with a convertFromString<T> specialization (e.g. NodeType,
   PortDirection) were never dispatched to it — the fallback tried
   convertFromString<int> which fails for named strings like "Control".

The fix adds a null check for config().enums, tries numeric parsing
via std::from_chars for integer enum values, then falls back to
convertFromString<T>() for types with user-provided specializations.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 FIXME.md                             |  2 +-
 include/behaviortree_cpp/tree_node.h | 23 +++++++---
 tests/gtest_enums.cpp                | 65 ++++++++++++++++++++++++++++
 3 files changed, 82 insertions(+), 8 deletions(-)

diff --git a/FIXME.md b/FIXME.md
index cc92226cc..b6306b5a1 100644
--- a/FIXME.md
+++ b/FIXME.md
@@ -49,7 +49,7 @@ This file tracks reported bugs from GitHub issues. For each bug, the workflow is
 - **Component:** `include/behaviortree_cpp/decorators/loop_node.h`
 - **Test file:** `tests/gtest_decorator.cpp` (or new)
 
-### [ ] #948 - ParseString errors with custom enum types
+### [x] #948 - ParseString errors with custom enum types
 - **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/948
 - **Summary:** `parseString` in `tree_node.h` has an unsafe `find` on an unordered_map that may not be instantiated yet if `getInput` is called during construction. Also, custom enum types cannot be properly parsed via `convertFromString`.
 - **Component:** `include/behaviortree_cpp/tree_node.h`, `include/behaviortree_cpp/basic_types.h`
diff --git a/include/behaviortree_cpp/tree_node.h b/include/behaviortree_cpp/tree_node.h
index d91e36e15..d95d4e017 100644
--- a/include/behaviortree_cpp/tree_node.h
+++ b/include/behaviortree_cpp/tree_node.h
@@ -20,6 +20,7 @@
 #include "behaviortree_cpp/utils/strcat.hpp"
 #include "behaviortree_cpp/utils/wakeup_signal.hpp"
 
+#include <charconv>
 #include <exception>
 #include <map>
 #include <utility>
@@ -432,17 +433,25 @@ T TreeNode::parseString(const std::string& str) const
 {
   if constexpr(std::is_enum_v<T> && !std::is_same_v<T, NodeStatus>)
   {
-    auto it = config().enums->find(str);
-    // conversion available
-    if(it != config().enums->end())
+    // Check the ScriptingEnumsRegistry first, if available.
+    if(config().enums)
     {
-      return static_cast<T>(it->second);
+      auto it = config().enums->find(str);
+      if(it != config().enums->end())
+      {
+        return static_cast<T>(it->second);
+      }
     }
-    else
+    // Try numeric conversion (e.g. "2" for an enum value).
+    int tmp = 0;
+    auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), tmp);
+    if(ec == std::errc() && ptr == str.data() + str.size())
     {
-      // hopefully str contains a number that can be parsed. May throw
-      return static_cast<T>(convertFromString<int>(str));
+      return static_cast<T>(tmp);
     }
+    // Fall back to convertFromString<T>, which uses a user-provided
+    // specialization if one exists. Issue #948.
+    return convertFromString<T>(str);
   }
   return convertFromString<T>(str);
 }
diff --git a/tests/gtest_enums.cpp b/tests/gtest_enums.cpp
index c15f50ece..379434622 100644
--- a/tests/gtest_enums.cpp
+++ b/tests/gtest_enums.cpp
@@ -240,3 +240,68 @@ TEST(Enums, SubtreeRemapping)
   ASSERT_EQ(status, NodeStatus::SUCCESS);
   ASSERT_EQ(tree.rootBlackboard()->get<BatteryStatus>("fault_status"), LOW_BATTERY);
 }
+
+// Issue #948: enums with a convertFromString<T> specialization should be parsed
+// correctly via getInput, without requiring ScriptingEnumsRegistry.
+class ActionWithNodeType : public SyncActionNode
+{
+public:
+  ActionWithNodeType(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    auto res = getInput<NodeType>("type");
+    if(!res)
+    {
+      throw RuntimeError("getInput failed: " + res.error());
+    }
+    parsed_type = res.value();
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { InputPort<NodeType>("type") };
+  }
+
+  NodeType parsed_type = NodeType::UNDEFINED;
+};
+
+TEST(Enums, ParseEnumWithConvertFromString_Issue948)
+{
+  std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <Sequence>
+          <ActionWithNodeType name="test_action" type="Action"/>
+          <ActionWithNodeType name="test_control" type="Control"/>
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<ActionWithNodeType>("ActionWithNodeType");
+  // Deliberately NOT registering NodeType in ScriptingEnumsRegistry.
+  // convertFromString<NodeType> exists and should be used as fallback.
+
+  auto tree = factory.createTreeFromText(xml_txt);
+  NodeStatus status = tree.tickWhileRunning();
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+
+  for(const auto& node : tree.subtrees.front()->nodes)
+  {
+    if(auto typed = dynamic_cast<ActionWithNodeType*>(node.get()))
+    {
+      if(typed->name() == "test_action")
+      {
+        ASSERT_EQ(NodeType::ACTION, typed->parsed_type);
+      }
+      else if(typed->name() == "test_control")
+      {
+        ASSERT_EQ(NodeType::CONTROL, typed->parsed_type);
+      }
+    }
+  }
+}

From f840dca94ce1f0f234c17f1af3024e1ad4262d7e Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Sat, 31 Jan 2026 09:13:33 +0100
Subject: [PATCH 08/11] Add regression test for #858: getInput with default
 port value

The bug (getInput throwing std::out_of_range when a port has a default
value but is not specified in XML) was already fixed in the current
code. getInputStamped now properly falls back to the manifest's default
value using find() instead of at(). Adding a regression test to prevent
future regressions.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 FIXME.md              |  2 +-
 tests/gtest_ports.cpp | 55 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/FIXME.md b/FIXME.md
index b6306b5a1..9982899e5 100644
--- a/FIXME.md
+++ b/FIXME.md
@@ -55,7 +55,7 @@ This file tracks reported bugs from GitHub issues. For each bug, the workflow is
 - **Component:** `include/behaviortree_cpp/tree_node.h`, `include/behaviortree_cpp/basic_types.h`
 - **Test file:** `tests/gtest_ports.cpp`
 
-### [ ] #858 - getInput throws when default parameter is passed
+### [x] #858 - getInput throws when default parameter is passed
 - **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/858
 - **Summary:** Calling `getInput` with a default parameter value throws `std::out_of_range` (`_Map_base::at`). The internal map lookup fails when the port has a default value but the entry does not exist in the expected location.
 - **Component:** `include/behaviortree_cpp/tree_node.h`
diff --git a/tests/gtest_ports.cpp b/tests/gtest_ports.cpp
index 81a5731a1..2bc43bdab 100644
--- a/tests/gtest_ports.cpp
+++ b/tests/gtest_ports.cpp
@@ -759,3 +759,58 @@ TEST(PortTest, LoopNodeAcceptsVector_Issue969)
   EXPECT_DOUBLE_EQ(collected[1], 20.0);
   EXPECT_DOUBLE_EQ(collected[2], 30.0);
 }
+
+// Issue #858: getInput should return the default value declared in
+// providedPorts when the XML does not specify the port.
+class ActionWithDefaultPort : public SyncActionNode
+{
+public:
+  ActionWithDefaultPort(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    auto res = getInput<std::string>("log_name");
+    if(!res)
+    {
+      throw RuntimeError("getInput failed: " + res.error());
+    }
+    result = res.value();
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { InputPort<std::string>("log_name", "my_default_logger", "Logger name"),
+             InputPort<std::string>("message", "Message to be logged") };
+  }
+
+  std::string result;
+};
+
+TEST(PortTest, GetInputDefaultValue_Issue858)
+{
+  // XML does NOT specify "log_name" — should use the default from providedPorts
+  std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <ActionWithDefaultPort message="hello"/>
+      </BehaviorTree>
+    </root>)";
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<ActionWithDefaultPort>("ActionWithDefaultPort");
+  auto tree = factory.createTreeFromText(xml_txt);
+  auto status = tree.tickWhileRunning();
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+
+  for(const auto& node : tree.subtrees.front()->nodes)
+  {
+    if(auto action = dynamic_cast<ActionWithDefaultPort*>(node.get()))
+    {
+      ASSERT_EQ("my_default_logger", action->result);
+    }
+  }
+}

From e9c4a4b05f00f2d664a05292c13a79568b4cfe43 Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Sat, 31 Jan 2026 09:20:37 +0100
Subject: [PATCH 09/11] Fix #974: numeric comparison for string-valued
 blackboard entries in scripts

When blackboard values are stored as strings (e.g. via
blackboard->set(key, value.dump())), scripting comparisons between
two such entries used lexicographic ordering instead of numeric.
This caused "9" < "10" to evaluate as false.

The fix attempts numeric parsing via strtod when both operands in a
comparison are strings. If both parse as valid numbers, numeric
comparison is used; otherwise falls back to lexicographic comparison.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 FIXME.md                                      |  2 +-
 .../behaviortree_cpp/scripting/operators.hpp  | 30 +++++++++++++++---
 tests/gtest_blackboard.cpp                    | 31 +++++++++++++++++++
 3 files changed, 58 insertions(+), 5 deletions(-)

diff --git a/FIXME.md b/FIXME.md
index 9982899e5..b501b9bc7 100644
--- a/FIXME.md
+++ b/FIXME.md
@@ -65,7 +65,7 @@ This file tracks reported bugs from GitHub issues. For each bug, the workflow is
 
 ## Blackboard
 
-### [ ] #974 - Blackboard set() stores values as string type
+### [x] #974 - Blackboard set() stores values as string type
 - **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/974
 - **Summary:** When using `blackboard->set(key, value.dump())` to set numeric values from JSON, the blackboard stores them as strings. Subsequent scripting operations with numeric operators fail because string types cannot be compared numerically.
 - **Component:** `src/blackboard.cpp`, `include/behaviortree_cpp/blackboard.h`
diff --git a/include/behaviortree_cpp/scripting/operators.hpp b/include/behaviortree_cpp/scripting/operators.hpp
index 7df8af4d0..6aaa15b50 100644
--- a/include/behaviortree_cpp/scripting/operators.hpp
+++ b/include/behaviortree_cpp/scripting/operators.hpp
@@ -16,6 +16,7 @@
 #include "behaviortree_cpp/scripting/script_parser.hpp"
 
 #include <cmath>
+#include <cstdlib>
 #include <memory>
 #include <string>
 #include <vector>
@@ -407,11 +408,32 @@ struct ExprComparison : ExprBase
       }
       else if(lhs_v.isString() && rhs_v.isString())
       {
-        auto lv = lhs_v.cast<SimpleString>();
-        auto rv = rhs_v.cast<SimpleString>();
-        if(!SwitchImpl(lv, rv, ops[i]))
+        // Try numeric comparison when both strings are parseable as numbers.
+        // This handles values set via blackboard->set(key, "42"). Issue #974.
+        auto ls = lhs_v.cast<std::string>();
+        auto rs = rhs_v.cast<std::string>();
+        char* lend = nullptr;
+        char* rend = nullptr;
+        double ld = std::strtod(ls.c_str(), &lend);
+        double rd = std::strtod(rs.c_str(), &rend);
+        bool l_numeric = (lend == ls.c_str() + ls.size()) && !ls.empty();
+        bool r_numeric = (rend == rs.c_str() + rs.size()) && !rs.empty();
+
+        if(l_numeric && r_numeric)
         {
-          return False;
+          if(!SwitchImpl(ld, rd, ops[i]))
+          {
+            return False;
+          }
+        }
+        else
+        {
+          auto lv = lhs_v.cast<SimpleString>();
+          auto rv = rhs_v.cast<SimpleString>();
+          if(!SwitchImpl(lv, rv, ops[i]))
+          {
+            return False;
+          }
         }
       }
       else if(lhs_v.isString() && rhs_v.isNumber())
diff --git a/tests/gtest_blackboard.cpp b/tests/gtest_blackboard.cpp
index 2c10e78d8..41f6008c9 100644
--- a/tests/gtest_blackboard.cpp
+++ b/tests/gtest_blackboard.cpp
@@ -745,3 +745,34 @@ TEST(BlackboardTest, SetBlackboard_WithPortRemapping)
   // Tick till the end with no crashes
   ASSERT_NO_THROW(tree.tickWhileRunning(););
 }
+
+// Issue #974: blackboard->set(key, "42") stores a string.
+// When two string-valued blackboard entries are compared in a script,
+// numeric comparison should be used if both strings are parseable as numbers.
+// "9" < "10" is false lexicographically but true numerically.
+TEST(BlackboardTest, StringSetNumericScriptComparison_Issue974)
+{
+  auto bb = Blackboard::create();
+  bb->set("a", std::string("9"));
+  bb->set("b", std::string("10"));
+
+  BehaviorTreeFactory factory;
+
+  std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <Sequence>
+          <Script code=" result := false "/>
+          <Script code=" result := (a < b) "/>
+          <AlwaysSuccess _successIf="result"/>
+        </Sequence>
+      </BehaviorTree>
+    </root>)";
+
+  auto tree = factory.createTreeFromText(xml_txt, bb);
+  auto status = tree.tickWhileRunning();
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+  // 9 < 10 is true numerically, even though "9" > "10" lexicographically
+  ASSERT_TRUE(bb->get<bool>("result"));
+}

From e396822c4894f271158bdd9eaf31f2deeb134eef Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Sat, 31 Jan 2026 09:28:32 +0100
Subject: [PATCH 10/11] Fix #942: getLockedPortContent creates entry for
 default-remapped ports

When a port declares a default blackboard remapping (e.g., "{=}") but
the XML doesn't explicitly specify the port, getLockedPortContent
returned an empty AnyPtrLocked because no blackboard entry existed.

The fix lazily creates the blackboard entry using the port's type info
from the manifest when the entry is missing but the remapped key is
valid. This makes getLockedPortContent consistent with the expectation
that default-remapped ports produce usable locked references.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 FIXME.md                   |  4 ++-
 src/tree_node.cpp          | 16 +++++++++-
 tests/gtest_blackboard.cpp | 61 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/FIXME.md b/FIXME.md
index b501b9bc7..3f0222939 100644
--- a/FIXME.md
+++ b/FIXME.md
@@ -5,6 +5,8 @@ This file tracks reported bugs from GitHub issues. For each bug, the workflow is
 2. Evaluate whether the behavior diverges from intended library semantics
 3. Fix the issue (if confirmed as a bug)
 
+**IMPORTANT:** NEVER modify existing tests that were not created in this branch. Only add new tests.
+
 ---
 
 ## Scripting / Script Parser
@@ -71,7 +73,7 @@ This file tracks reported bugs from GitHub issues. For each bug, the workflow is
 - **Component:** `src/blackboard.cpp`, `include/behaviortree_cpp/blackboard.h`
 - **Test file:** `tests/gtest_blackboard.cpp`
 
-### [ ] #942 - Default blackboard entry not created for locked content
+### [x] #942 - Default blackboard entry not created for locked content
 - **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/942
 - **Summary:** When using `getLockedPortContent` on a port with a default blackboard entry, no blackboard entry is actually created on the first call. The returned `AnyPtrLocked` is a default/empty value not placed into the blackboard.
 - **Component:** `src/blackboard.cpp`, `include/behaviortree_cpp/blackboard.h`
diff --git a/src/tree_node.cpp b/src/tree_node.cpp
index 52b2d087f..d464d6af9 100644
--- a/src/tree_node.cpp
+++ b/src/tree_node.cpp
@@ -479,7 +479,21 @@ AnyPtrLocked BT::TreeNode::getLockedPortContent(const std::string& key)
 {
   if(auto remapped_key = getRemappedKey(key, getRawPortValue(key)))
   {
-    return _p->config.blackboard->getAnyLocked(std::string(*remapped_key));
+    const auto bb_key = std::string(*remapped_key);
+    auto result = _p->config.blackboard->getAnyLocked(bb_key);
+    if(!result && _p->config.manifest)
+    {
+      // Entry doesn't exist yet. Create it using the port's type info
+      // from the manifest so that getLockedPortContent works even when
+      // the port is not explicitly declared in XML. Issue #942.
+      auto port_it = _p->config.manifest->ports.find(key);
+      if(port_it != _p->config.manifest->ports.end())
+      {
+        _p->config.blackboard->createEntry(bb_key, port_it->second);
+        result = _p->config.blackboard->getAnyLocked(bb_key);
+      }
+    }
+    return result;
   }
   return {};
 }
diff --git a/tests/gtest_blackboard.cpp b/tests/gtest_blackboard.cpp
index 41f6008c9..29953bb52 100644
--- a/tests/gtest_blackboard.cpp
+++ b/tests/gtest_blackboard.cpp
@@ -746,6 +746,67 @@ TEST(BlackboardTest, SetBlackboard_WithPortRemapping)
   ASSERT_NO_THROW(tree.tickWhileRunning(););
 }
 
+// Issue #942: getLockedPortContent should return a valid locked reference
+// even when the port is not explicitly declared in XML, as long as there is
+// a default blackboard remapping (e.g., "{=}").
+class ActionWithLockedPort : public SyncActionNode
+{
+public:
+  ActionWithLockedPort(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
+  {}
+
+  NodeStatus tick() override
+  {
+    auto any_locked = getLockedPortContent("value");
+    if(!any_locked)
+    {
+      locked_valid = false;
+      return NodeStatus::FAILURE;
+    }
+    locked_valid = true;
+    // Assign a value through the locked reference
+    any_locked.assign(42);
+    return NodeStatus::SUCCESS;
+  }
+
+  static PortsList providedPorts()
+  {
+    return { BidirectionalPort<int>("value", "{=}", "A value with default BB remap") };
+  }
+
+  bool locked_valid = false;
+};
+
+TEST(BlackboardTest, GetLockedPortContentWithDefault_Issue942)
+{
+  // XML does NOT specify the "value" port — relies on default "{=}"
+  std::string xml_txt = R"(
+    <root BTCPP_format="4" >
+      <BehaviorTree ID="Main">
+        <ActionWithLockedPort/>
+      </BehaviorTree>
+    </root>)";
+
+  BehaviorTreeFactory factory;
+  factory.registerNodeType<ActionWithLockedPort>("ActionWithLockedPort");
+  auto tree = factory.createTreeFromText(xml_txt);
+  auto status = tree.tickWhileRunning();
+
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+
+  for(const auto& node : tree.subtrees.front()->nodes)
+  {
+    if(auto action = dynamic_cast<ActionWithLockedPort*>(node.get()))
+    {
+      ASSERT_TRUE(action->locked_valid);
+    }
+  }
+
+  // The value should be accessible from the blackboard
+  ASSERT_EQ(tree.rootBlackboard()->get<int>("value"), 42);
+}
+
 // Issue #974: blackboard->set(key, "42") stores a string.
 // When two string-valued blackboard entries are compared in a script,
 // numeric comparison should be used if both strings are parseable as numbers.

From 0e737fd8b19c3324b23701b3c10052c4763070dd Mon Sep 17 00:00:00 2001
From: Davide Faconti <davide.faconti@gmail.com>
Date: Sat, 31 Jan 2026 09:30:35 +0100
Subject: [PATCH 11/11] Fix #408: debugMessage shows type info for remapped
 subtree entries

debugMessage() only printed the remapping direction for subtree entries
(e.g., "[local] remapped to port of parent tree [parent]") without
showing the type of the parent blackboard entry. Now it resolves the
parent entry and appends the type name, making the debug output useful
for diagnosing subtree port remapping issues.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 FIXME.md                   |  2 +-
 src/blackboard.cpp         | 17 +++++++++++++++--
 tests/gtest_blackboard.cpp | 28 ++++++++++++++++++++++++++++
 3 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/FIXME.md b/FIXME.md
index 3f0222939..8c6a35279 100644
--- a/FIXME.md
+++ b/FIXME.md
@@ -79,7 +79,7 @@ This file tracks reported bugs from GitHub issues. For each bug, the workflow is
 - **Component:** `src/blackboard.cpp`, `include/behaviortree_cpp/blackboard.h`
 - **Test file:** `tests/gtest_blackboard.cpp`
 
-### [ ] #408 - debugMessage does not print parent values in SubTree
+### [x] #408 - debugMessage does not print parent values in SubTree
 - **URL:** https://github.com/BehaviorTree/BehaviorTree.CPP/issues/408
 - **Summary:** `config().blackboard->debugMessage()` inside a SubTree node's constructor does not show remapped entries from the parent blackboard. The function only checks `internal_to_external_` after finding an entry in `storage_`.
 - **Component:** `src/blackboard.cpp`
diff --git a/src/blackboard.cpp b/src/blackboard.cpp
index 64163a7d6..ad9db06e6 100644
--- a/src/blackboard.cpp
+++ b/src/blackboard.cpp
@@ -116,8 +116,21 @@ void Blackboard::debugMessage() const
 
   for(const auto& [from, to] : internal_to_external_)
   {
-    std::cout << "[" << from << "] remapped to port of parent tree [" << to << "]"
-              << std::endl;
+    std::cout << "[" << from << "] remapped to port of parent tree [" << to << "]";
+    // Show the type of the remapped entry from the parent. Issue #408.
+    if(auto parent = parent_bb_.lock())
+    {
+      if(auto entry = parent->getEntry(to))
+      {
+        auto port_type = entry->info.type();
+        if(port_type == typeid(void))
+        {
+          port_type = entry->value.type();
+        }
+        std::cout << " (" << BT::demangle(port_type) << ")";
+      }
+    }
+    std::cout << std::endl;
   }
 }
 
diff --git a/tests/gtest_blackboard.cpp b/tests/gtest_blackboard.cpp
index 29953bb52..f53ed9be8 100644
--- a/tests/gtest_blackboard.cpp
+++ b/tests/gtest_blackboard.cpp
@@ -837,3 +837,31 @@ TEST(BlackboardTest, StringSetNumericScriptComparison_Issue974)
   // 9 < 10 is true numerically, even though "9" > "10" lexicographically
   ASSERT_TRUE(bb->get<bool>("result"));
 }
+
+// Issue #408: debugMessage should show remapped entries from parent blackboard
+TEST(BlackboardTest, DebugMessageShowsRemappedEntries_Issue408)
+{
+  // Create parent BB with a value
+  auto parent_bb = Blackboard::create();
+  parent_bb->set("parent_value", 42);
+
+  // Create child BB with remapping
+  auto child_bb = Blackboard::create(parent_bb);
+  child_bb->addSubtreeRemapping("local_name", "parent_value");
+
+  // Capture debugMessage output
+  testing::internal::CaptureStdout();
+  child_bb->debugMessage();
+  std::string output = testing::internal::GetCapturedStdout();
+
+  // The output should contain the remapped key with its type info from parent
+  EXPECT_TRUE(output.find("local_name") != std::string::npos)
+      << "debugMessage output should mention 'local_name'. Got: " << output;
+  EXPECT_TRUE(output.find("parent_value") != std::string::npos)
+      << "debugMessage output should mention 'parent_value'. Got: " << output;
+  // The output should show the parent entry's type, not just the remapping
+  EXPECT_TRUE(output.find("int") != std::string::npos) << "debugMessage output should "
+                                                          "show the type of the remapped "
+                                                          "entry. Got: "
+                                                       << output;
+}