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>

Author: facontidavide

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
         {

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);
+}