Add Strategy config facade

- Add `StrategyCore` and macro-generated `config()` accessors
- Return `StrategyConfig` from macro-wired strategy calls
- Classify `StrategyCore` config as plug-in host-owned
- Document strategy config access in the Rust how-to

Author: cjdsellers

crates/plugin/tests/surface_alignment.rs

@@ -192,8 +192,9 @@ const PLUGIN_STRATEGY_CORE_BRIDGED_METHODS: &[(&str, &str)] = &[("strategy_id",
 const PLUGIN_STRATEGY_CORE_DEFERRED_METHODS: &[&str] = &[];
 
 const PLUGIN_STRATEGY_CORE_HOST_OWNED_METHODS: &[&str] = &[
-    // Construction and registration mutate host runtime state
+    // Construction, config reads, and registration stay host-owned
     "new",
+    "config",
     "change_id",
     "change_order_id_tag",
     "order_id_tag",

crates/trading/src/macros.rs

@@ -20,6 +20,8 @@
 /// The struct must contain a field of type [`StrategyCore`](crate::strategy::StrategyCore).
 /// By default the macro expects the field to be named `core`; pass a second argument
 /// to use a different name.
+/// The macro also adds an inherent `config()` method on the strategy type which
+/// returns the user-supplied [`StrategyConfig`](crate::strategy::StrategyConfig).
 ///
 /// An optional brace-delimited block adds extra methods to the generated `impl Strategy`.
 /// Do not redefine `core` or `core_mut` inside the block; they are already generated
@@ -75,6 +77,15 @@ macro_rules! nautilus_strategy {
         $crate::nautilus_strategy!($ty, core, { $($extra)* });
     };
     ($ty:ty, $field:ident, { $($extra:item)* }) => {
+        impl $ty {
+            /// Returns the strategy configuration.
+            #[allow(dead_code, unreachable_pub)]
+            #[must_use]
+            pub fn config(&self) -> &$crate::strategy::StrategyConfig {
+                self.$field.config()
+            }
+        }
+
         impl $crate::_macro_reexports::DataActorNative for $ty {
             fn core(&self) -> &$crate::_macro_reexports::DataActorCore {
                 $crate::_macro_reexports::DataActorNative::core(&self.$field)

crates/trading/src/strategy/core.rs

@@ -178,6 +178,12 @@ impl StrategyCore {
         }
     }
 
+    /// Returns the strategy configuration.
+    #[must_use]
+    pub fn config(&self) -> &StrategyConfig {
+        &self.config
+    }
+
     /// Changes the strategy ID before registration.
     pub fn change_id(&mut self, strategy_id: StrategyId) {
         let strategy_id = strategy_id_with_order_id_tag(strategy_id, self.order_id_tag());

crates/trading/src/strategy/mod.rs

@@ -4609,18 +4609,21 @@ mod tests {
             core: StrategyCore::new(config.clone()),
         };
         assert_eq!(simple.strategy_id(), config.strategy_id);
+        assert_eq!(simple.config().order_id_tag, config.order_id_tag);
         assert_eq!(simple.actor_id(), ActorId::from("MACRO-001"));
 
         let hooks = MacroTestWithHooks {
             core: StrategyCore::new(config.clone()),
         };
         assert_eq!(hooks.strategy_id(), config.strategy_id);
+        assert_eq!(hooks.config().order_id_tag, config.order_id_tag);
         assert_eq!(hooks.actor_id(), ActorId::from("MACRO-001"));
 
         let custom = MacroTestCustomField {
             inner: StrategyCore::new(config.clone()),
         };
         assert_eq!(custom.strategy_id(), config.strategy_id);
+        assert_eq!(custom.config().order_id_tag, config.order_id_tag);
         assert_eq!(custom.actor_id(), ActorId::from("MACRO-001"));
         assert!(custom.external_order_claims().is_none());
     }

docs/how_to/write_rust_strategy.md

@@ -59,6 +59,8 @@ The `nautilus_strategy!` macro generates the native runtime wiring used by
 registration and the `Strategy` trait impl. By default it delegates to a field
 named `core`; pass a second argument for a different field name. The macro
 does not make your strategy or its `StrategyCore` deref to runtime internals.
+It also adds `config()`, which returns the `StrategyConfig` passed to
+`StrategyCore::new`.
 
 Runtime registration uses blanket `Actor` and `Component` implementations that
 require native wiring and `Debug`. The macro supplies the native wiring;