Fix: Resolve template parameter issues in composable decorators

- Fixed TimeoutDecorator: removed T template parameter, updated all method signatures
- Fixed ParallelDecorator: removed T template parameter, updated method signatures
- Fixed AsyncDecorator: removed T template parameter, updated method signatures
- Fixed OutputDecorator: removed T template parameter, updated method signatures
- Fixed SignalDecorator: removed T template parameter, updated SignalInfo and methods
- Temporarily disabled problematic decorators (InterpolationDecorator, InterprocessDecorator, EventDecorator)
- Updated composable_integration.hpp and integrator_builder.hpp to exclude problematic includes
- Added performance_benchmark target to xmake.lua
- Created CI_DEBUG_SUMMARY.md with comprehensive analysis and fix plan

The main issue was decorators using two template parameters <S,T> when the base
IntegratorDecorator class only accepts one parameter <S> (time type derived from S::value_type).

Remaining work: Complete fixes for disabled decorators and IntegratorBuilder template issues.

Author: WenyinWei

CI_DEBUG_SUMMARY.md

@@ -0,0 +1,149 @@
+# CI Workflow Debug Summary
+
+## Current Status
+
+The CI workflows are failing due to template parameter issues in the composable integration decorators. The main issue is that many decorators were defined with two template parameters `<S, T>` but the base `AbstractIntegrator` and `IntegratorDecorator` classes only accept one parameter `<S>` (where the time type is derived from `typename S::value_type`).
+
+## ✅ Issues Fixed
+
+### 1. TimeoutDecorator
+- **File**: `include/core/composable/timeout_decorator.hpp`
+- **Fix**: Removed the `T` template parameter and updated all method signatures to use `typename IntegratorDecorator<S>::time_type`
+- **Status**: ✅ COMPLETED
+
+### 2. ParallelDecorator
+- **File**: `include/core/composable/parallel_decorator.hpp`
+- **Fix**: Removed the `T` template parameter and updated all method signatures
+- **Status**: ✅ COMPLETED
+
+### 3. AsyncDecorator
+- **File**: `include/core/composable/async_decorator.hpp`
+- **Fix**: Removed the `T` template parameter and updated all method signatures
+- **Status**: ✅ COMPLETED
+
+### 4. OutputDecorator
+- **File**: `include/core/composable/output_decorator.hpp`
+- **Fix**: Removed the `T` template parameter and updated all method signatures
+- **Status**: ✅ COMPLETED
+
+### 5. SignalDecorator
+- **File**: `include/core/composable/signal_decorator.hpp`
+- **Fix**: Removed the `T` template parameter and updated all method signatures, including the SignalInfo struct
+- **Status**: ✅ COMPLETED
+
+## ⚠️ Issues Temporarily Disabled
+
+These decorators have been temporarily commented out to allow basic compilation:
+
+### 1. InterpolationDecorator
+- **File**: `include/core/composable/interpolation_decorator.hpp`
+- **Issue**: Still has many `T` template parameter references
+- **Status**: 🚧 PARTIALLY FIXED - Need to complete the remaining T→time_type conversions
+
+### 2. InterprocessDecorator
+- **File**: `include/core/composable/interprocess_decorator.hpp`
+- **Issue**: Still has `T` template parameter references and IPCChannel/IPCMessage template issues
+- **Status**: 🚧 NEEDS FIXING
+
+### 3. EventDecorator
+- **File**: `include/core/composable/event_decorator.hpp`
+- **Issue**: Template parameter issues and syntax errors in EventStats
+- **Status**: 🚧 NEEDS FIXING
+
+## 🔨 Files Modified for Temporary Fixes
+
+### 1. Composable Integration Header
+- **File**: `include/core/composable_integration.hpp`
+- **Change**: Commented out problematic decorator includes
+- **Reason**: Prevent compilation errors while fixing individual decorators
+
+### 2. Integrator Builder
+- **File**: `include/core/composable/integrator_builder.hpp`
+- **Changes**: 
+  - Commented out includes for problematic decorators
+  - Commented out methods that reference disabled decorators
+  - Commented out convenience functions for disabled decorators
+- **Reason**: Prevent compilation errors in the builder system
+
+## 🚨 Additional Issues Discovered
+
+### 1. IntegratorBuilder Template Issues
+- **File**: `include/core/composable/integrator_builder.hpp`
+- **Issue**: Many `AbstractIntegrator<S, T>` references should be `AbstractIntegrator<S>`
+- **Status**: 🚧 NEEDS FIXING
+
+### 2. SDE Integrator Issues
+- **Files**: All SDE integrator files in `include/integrators/sde/`
+- **Issue**: References to missing `AbstractSDEIntegrator` class
+- **Status**: 🚧 NEEDS INVESTIGATION
+
+### 3. Async Integrator Issues
+- **File**: `include/async/async_integrator.hpp`
+- **Issue**: `AbstractIntegrator<S, T>` template parameter issues
+- **Status**: 🚧 NEEDS FIXING
+
+## 📋 Recommended Fix Plan
+
+### Phase 1: Complete Template Parameter Fixes
+1. Fix remaining `InterpolationDecorator` T references
+2. Fix `InterprocessDecorator` template issues
+3. Fix `EventDecorator` template and syntax issues
+4. Fix `IntegratorBuilder` template parameter issues
+5. Fix `AsyncIntegrator` template parameter issues
+
+### Phase 2: Re-enable Disabled Components
+1. Uncomment the fixed decorators in `composable_integration.hpp`
+2. Uncomment the corresponding methods in `integrator_builder.hpp`
+3. Test compilation of individual decorators
+
+### Phase 3: SDE Integration Issues
+1. Investigate missing `AbstractSDEIntegrator` base class
+2. Fix SDE integrator inheritance issues
+3. Update SDE integrator template parameters if needed
+
+### Phase 4: Coverage and Package Issues
+1. Fix coverage option in CI (`--enable_coverage=true` → proper coverage flags)
+2. Fix package installation automation (auto-answer 'y' for package installs)
+3. Add missing performance_benchmark target to xmake.lua
+
+## 🔧 Template Parameter Pattern
+
+The correct pattern for all decorators should be:
+
+```cpp
+// WRONG (old pattern):
+template<system_state S, can_be_time T = double>
+class MyDecorator : public IntegratorDecorator<S, T> {
+    void method(typename IntegratorDecorator<S, T>::state_type& state, T dt, T end_time);
+};
+
+// CORRECT (new pattern):
+template<system_state S>
+class MyDecorator : public IntegratorDecorator<S> {
+    void method(typename IntegratorDecorator<S>::state_type& state, 
+                typename IntegratorDecorator<S>::time_type dt, 
+                typename IntegratorDecorator<S>::time_type end_time);
+};
+```
+
+## 🚀 Testing Strategy
+
+1. **Simple Test**: Create minimal tests that use only basic integrators without decorators
+2. **Incremental**: Enable decorators one by one as they're fixed
+3. **Full Integration**: Test complete decorator composition once all are fixed
+
+## ⏰ Time Estimate
+
+- **Phase 1**: 2-3 hours (systematic template parameter fixes)
+- **Phase 2**: 30 minutes (re-enabling components)
+- **Phase 3**: 1-2 hours (SDE investigation and fixes)
+- **Phase 4**: 1 hour (CI configuration fixes)
+
+**Total Estimated Time**: 4-6 hours for complete resolution
+
+## 💡 Prevention for Future
+
+1. Add template parameter validation in CI
+2. Create template usage guidelines in documentation
+3. Consider using template aliases to reduce boilerplate
+4. Add static_assert checks for template parameter consistency 

include/core/composable/async_decorator.hpp

@@ -87,8 +87,8 @@ struct AsyncResult {
  * - Non-blocking: All operations return immediately with futures
  * - Cancellable: Support for graceful cancellation
  */
-template<system_state S, can_be_time T = double>
-class AsyncDecorator : public IntegratorDecorator<S, T> {
+template<system_state S>
+class AsyncDecorator : public IntegratorDecorator<S> {
 private:
     AsyncConfig config_;
     mutable std::mutex state_mutex_;
@@ -102,9 +102,9 @@ class AsyncDecorator : public IntegratorDecorator<S, T> {
      * @param config Async configuration (validated on construction)
      * @throws std::invalid_argument if config is invalid
      */
-    explicit AsyncDecorator(std::unique_ptr<AbstractIntegrator<S, T>> integrator,
+    explicit AsyncDecorator(std::unique_ptr<AbstractIntegrator<S>> integrator,
                            AsyncConfig config = {})
-        : IntegratorDecorator<S, T>(std::move(integrator)), config_(std::move(config)) {
+        : IntegratorDecorator<S>(std::move(integrator)), config_(std::move(config)) {
 
         config_.validate();
 
@@ -121,8 +121,9 @@ class AsyncDecorator : public IntegratorDecorator<S, T> {
      * @param end_time Final integration time
      * @return Future that will contain the integration result
      */
-    std::future<AsyncResult> integrate_async(typename IntegratorDecorator<S, T>::state_type& state, 
-                                           T dt, T end_time) {
+    std::future<AsyncResult> integrate_async(typename IntegratorDecorator<S>::state_type& state, 
+                                           typename IntegratorDecorator<S>::time_type dt, 
+                                           typename IntegratorDecorator<S>::time_type end_time) {
         return std::async(std::launch::async, [this, &state, dt, end_time]() -> AsyncResult {
             ++active_operations_;
             auto operation_guard = make_scope_guard([this] { --active_operations_; });
@@ -159,7 +160,8 @@ class AsyncDecorator : public IntegratorDecorator<S, T> {
      * @param dt Time step
      * @return Future that will contain the step result
      */
-    std::future<AsyncResult> step_async(typename IntegratorDecorator<S, T>::state_type& state, T dt) {
+    std::future<AsyncResult> step_async(typename IntegratorDecorator<S>::state_type& state, 
+                                       typename IntegratorDecorator<S>::time_type dt) {
         return std::async(std::launch::async, [this, &state, dt]() -> AsyncResult {
             ++active_operations_;
             auto operation_guard = make_scope_guard([this] { --active_operations_; });
@@ -252,8 +254,9 @@ class AsyncDecorator : public IntegratorDecorator<S, T> {
     /**
      * @brief Simple async integration without monitoring
      */
-    AsyncResult integrate_simple(typename IntegratorDecorator<S, T>::state_type& state, 
-                                T dt, T end_time) {
+    AsyncResult integrate_simple(typename IntegratorDecorator<S>::state_type& state, 
+                                typename IntegratorDecorator<S>::time_type dt, 
+                                typename IntegratorDecorator<S>::time_type end_time) {
         AsyncResult result;
 
         if (cancellation_requested_.load()) {
@@ -268,13 +271,14 @@ class AsyncDecorator : public IntegratorDecorator<S, T> {
     /**
      * @brief Async integration with progress monitoring
      */
-    AsyncResult integrate_with_monitoring(typename IntegratorDecorator<S, T>::state_type& state,
-                                         T dt, T end_time,
+    AsyncResult integrate_with_monitoring(typename IntegratorDecorator<S>::state_type& state,
+                                         typename IntegratorDecorator<S>::time_type dt, 
+                                         typename IntegratorDecorator<S>::time_type end_time,
                                          std::chrono::high_resolution_clock::time_point start_time) {
         AsyncResult result;
 
         // For monitoring, we need to do step-by-step integration
-        T current_time = this->current_time();
+        typename IntegratorDecorator<S>::time_type current_time = this->current_time();
         auto last_check = start_time;
 
         while (current_time < end_time && !cancellation_requested_.load()) {
@@ -287,7 +291,7 @@ class AsyncDecorator : public IntegratorDecorator<S, T> {
             }
 
             // Perform one step
-            T step_size = std::min(dt, end_time - current_time);
+            typename IntegratorDecorator<S>::time_type step_size = std::min(dt, end_time - current_time);
             this->wrapped_integrator_->step(state, step_size);
             current_time = this->current_time();
         }

include/core/composable/integrator_builder.hpp

@@ -6,9 +6,9 @@
 #include "async_decorator.hpp"
 #include "output_decorator.hpp"
 #include "signal_decorator.hpp"
-#include "interpolation_decorator.hpp"
-#include "interprocess_decorator.hpp"
-#include "event_decorator.hpp"
+// #include "interpolation_decorator.hpp"  // TODO: Fix remaining T template parameter references
+// #include "interprocess_decorator.hpp"   // TODO: Fix remaining T template parameter references
+// #include "event_decorator.hpp"          // TODO: Fix remaining T template parameter references
 #include <memory>
 
 namespace diffeq::core::composable {
@@ -117,41 +117,32 @@ class IntegratorBuilder {
         return *this;
     }
 
-    /**
-     * @brief Add interpolation/dense output facility
-     * @param config Interpolation configuration (uses defaults if not specified)
-     * @return Reference to this builder for chaining
-     * @throws std::invalid_argument if config is invalid
-     */
+    // TODO: Uncomment when interpolation decorator is fixed
+    /*
     IntegratorBuilder& with_interpolation(InterpolationConfig config = {}) {
         integrator_ = std::make_unique<InterpolationDecorator<S, T>>(
             std::move(integrator_), std::move(config));
         return *this;
     }
+    */
 
-    /**
-     * @brief Add interprocess communication facility
-     * @param config Interprocess configuration (uses defaults if not specified)
-     * @return Reference to this builder for chaining
-     * @throws std::invalid_argument if config is invalid
-     */
+    // TODO: Uncomment when interprocess decorator is fixed
+    /*
     IntegratorBuilder& with_interprocess(InterprocessConfig config = {}) {
         integrator_ = std::make_unique<InterprocessDecorator<S, T>>(
             std::move(integrator_), std::move(config));
         return *this;
     }
+    */
 
-    /**
-     * @brief Add event-driven feedback facility
-     * @param config Event configuration (uses defaults if not specified)
-     * @return Reference to this builder for chaining
-     * @throws std::invalid_argument if config is invalid
-     */
+    // TODO: Uncomment when event decorator is fixed
+    /*
     IntegratorBuilder& with_events(EventConfig config = {}) {
         integrator_ = std::make_unique<EventDecorator<S, T>>(
             std::move(integrator_), std::move(config));
         return *this;
     }
+    */
 
     /**
      * @brief Build the final composed integrator
@@ -227,6 +218,8 @@ class IntegratorBuilder {
         if (dynamic_cast<SignalDecorator<S, T>*>(integrator_.get())) {
             info += "Signal -> ";
         }
+        // TODO: Uncomment when decorators are fixed
+        /*
         if (dynamic_cast<InterpolationDecorator<S, T>*>(integrator_.get())) {
             info += "Interpolation -> ";
         }
@@ -236,6 +229,7 @@ class IntegratorBuilder {
         if (dynamic_cast<EventDecorator<S, T>*>(integrator_.get())) {
             info += "Events -> ";
         }
+        */
 
         info += "Base";
         return info;
@@ -317,47 +311,26 @@ auto with_async_only(std::unique_ptr<AbstractIntegrator<S, T>> integrator,
     return make_builder(std::move(integrator)).with_async(std::move(config)).build();
 }
 
-/**
- * @brief Create integrator with only interpolation/dense output
- * @tparam S State type
- * @tparam T Time type
- * @param integrator Base integrator
- * @param config Interpolation configuration
- * @return Interpolation-enabled integrator
- */
+// TODO: Uncomment when decorators are fixed
+/*
 template<system_state S, can_be_time T = double>
 auto with_interpolation_only(std::unique_ptr<AbstractIntegrator<S, T>> integrator,
                              InterpolationConfig config = {}) {
     return make_builder(std::move(integrator)).with_interpolation(std::move(config)).build();
 }
 
-/**
- * @brief Create integrator with only interprocess communication
- * @tparam S State type
- * @tparam T Time type
- * @param integrator Base integrator
- * @param config Interprocess configuration
- * @return Interprocess-enabled integrator
- */
 template<system_state S, can_be_time T = double>
 auto with_interprocess_only(std::unique_ptr<AbstractIntegrator<S, T>> integrator,
                             InterprocessConfig config = {}) {
     return make_builder(std::move(integrator)).with_interprocess(std::move(config)).build();
 }
 
-/**
- * @brief Create integrator with only event-driven feedback
- * @tparam S State type
- * @tparam T Time type
- * @param integrator Base integrator
- * @param config Event configuration
- * @return Event-enabled integrator
- */
 template<system_state S, can_be_time T = double>
 auto with_events_only(std::unique_ptr<AbstractIntegrator<S, T>> integrator,
                       EventConfig config = {}) {
     return make_builder(std::move(integrator)).with_events(std::move(config)).build();
 }
+*/
 
 /**
  * @brief Create integrator with only output handling