feat: production-ready kernel execution — replace all ecosystem stubs with real dispatch

crates/rustkernel-accounting/src/lib.rs

@@ -41,50 +41,32 @@ pub use temporal::TemporalCorrelation;
 pub fn register_all(
     registry: &rustkernel_core::registry::KernelRegistry,
 ) -> rustkernel_core::error::Result<()> {
-    use rustkernel_core::traits::GpuKernel;
-
     tracing::info!("Registering accounting kernels");
 
-    // CoA mapping kernel (1)
-    registry.register_metadata(
-        coa_mapping::ChartOfAccountsMapping::new()
-            .metadata()
-            .clone(),
-    )?;
+    // CoA mapping kernel (1) — Batch
+    registry.register_ring_metadata_from(coa_mapping::ChartOfAccountsMapping::new)?;
 
-    // Journal kernel (1)
-    registry.register_metadata(journal::JournalTransformation::new().metadata().clone())?;
+    // Journal kernel (1) — Batch
+    registry.register_ring_metadata_from(journal::JournalTransformation::new)?;
 
-    // Reconciliation kernel (1)
-    registry.register_metadata(reconciliation::GLReconciliation::new().metadata().clone())?;
+    // Reconciliation kernel (1) — Batch
+    registry.register_ring_metadata_from(reconciliation::GLReconciliation::new)?;
 
-    // Network analysis kernel (1)
-    registry.register_metadata(network::NetworkAnalysis::new().metadata().clone())?;
+    // Network analysis kernel (1) — Batch
+    registry.register_ring_metadata_from(network::NetworkAnalysis::new)?;
 
-    // Temporal kernel (1)
-    registry.register_metadata(temporal::TemporalCorrelation::new().metadata().clone())?;
+    // Temporal kernel (1) — Batch
+    registry.register_ring_metadata_from(temporal::TemporalCorrelation::new)?;
 
-    // Network generation batch kernel (1)
-    registry.register_metadata(
-        network_generation::NetworkGeneration::new()
-            .metadata()
-            .clone(),
-    )?;
+    // Network generation batch kernel (1) — Batch
+    registry.register_batch_typed(network_generation::NetworkGeneration::new)?;
 
-    // Network generation ring kernel (1)
-    registry.register_metadata(
-        network_generation::NetworkGenerationRing::new()
-            .metadata()
-            .clone(),
-    )?;
+    // Network generation ring kernel (1) — Ring
+    registry.register_ring_metadata_from(network_generation::NetworkGenerationRing::new)?;
 
-    // Detection kernels (2)
-    registry.register_metadata(
-        detection::SuspenseAccountDetection::new()
-            .metadata()
-            .clone(),
-    )?;
-    registry.register_metadata(detection::GaapViolationDetection::new().metadata().clone())?;
+    // Detection kernels (2) — Batch
+    registry.register_ring_metadata_from(detection::SuspenseAccountDetection::new)?;
+    registry.register_ring_metadata_from(detection::GaapViolationDetection::new)?;
 
     tracing::info!("Registered 9 accounting kernels");
     Ok(())

crates/rustkernel-audit/src/lib.rs

@@ -20,19 +20,13 @@ pub use types::*;
 pub fn register_all(
     registry: &rustkernel_core::registry::KernelRegistry,
 ) -> rustkernel_core::error::Result<()> {
-    use rustkernel_core::traits::GpuKernel;
-
     tracing::info!("Registering financial audit kernels");
 
-    // Feature extraction kernel (1)
-    registry.register_metadata(
-        feature_extraction::FeatureExtraction::new()
-            .metadata()
-            .clone(),
-    )?;
+    // Feature extraction kernel (1) - Batch
+    registry.register_batch_metadata_from(feature_extraction::FeatureExtraction::new)?;
 
-    // Hypergraph kernel (1)
-    registry.register_metadata(hypergraph::HypergraphConstruction::new().metadata().clone())?;
+    // Hypergraph kernel (1) - Batch
+    registry.register_batch_metadata_from(hypergraph::HypergraphConstruction::new)?;
 
     tracing::info!("Registered 2 financial audit kernels");
     Ok(())

crates/rustkernel-banking/src/lib.rs

@@ -35,12 +35,10 @@ pub use types::{
 pub fn register_all(
     registry: &rustkernel_core::registry::KernelRegistry,
 ) -> rustkernel_core::error::Result<()> {
-    use rustkernel_core::traits::GpuKernel;
-
     tracing::info!("Registering banking kernels");
 
-    // Fraud detection kernel (1)
-    registry.register_metadata(fraud::FraudPatternMatch::new().metadata().clone())?;
+    // Fraud detection kernel (1) - Ring
+    registry.register_ring_metadata_from(fraud::FraudPatternMatch::new)?;
 
     tracing::info!("Registered 1 banking kernel");
     Ok(())

crates/rustkernel-behavioral/src/lib.rs

@@ -48,33 +48,24 @@ pub use types::{
 pub fn register_all(
     registry: &rustkernel_core::registry::KernelRegistry,
 ) -> rustkernel_core::error::Result<()> {
-    use rustkernel_core::traits::GpuKernel;
-
     tracing::info!("Registering behavioral analytics kernels");
 
-    // Profiling kernels (2)
-    registry.register_metadata(profiling::BehavioralProfiling::new().metadata().clone())?;
-    registry.register_metadata(profiling::AnomalyProfiling::new().metadata().clone())?;
+    // Profiling kernels (2) - Ring
+    registry.register_ring_metadata_from(profiling::BehavioralProfiling::new)?;
+    registry.register_ring_metadata_from(profiling::AnomalyProfiling::new)?;
 
-    // Signature detection kernel (1)
-    registry.register_metadata(
-        signatures::FraudSignatureDetection::new()
-            .metadata()
-            .clone(),
-    )?;
+    // Signature detection kernel (1) - Ring
+    registry.register_ring_metadata_from(signatures::FraudSignatureDetection::new)?;
 
-    // Causal kernel (1)
-    registry.register_metadata(causal::CausalGraphConstruction::new().metadata().clone())?;
+    // Causal kernel (1) - Batch (uses register_ring_metadata_from because it only
+    // implements GpuKernel, not BatchKernel<I, O>; computation is via static methods)
+    registry.register_ring_metadata_from(causal::CausalGraphConstruction::new)?;
 
-    // Forensics kernel (1)
-    registry.register_metadata(forensics::ForensicQueryExecution::new().metadata().clone())?;
+    // Forensics kernel (1) - Batch (same as above)
+    registry.register_ring_metadata_from(forensics::ForensicQueryExecution::new)?;
 
-    // Correlation kernel (1)
-    registry.register_metadata(
-        correlation::EventCorrelationKernel::new()
-            .metadata()
-            .clone(),
-    )?;
+    // Correlation kernel (1) - Ring
+    registry.register_ring_metadata_from(correlation::EventCorrelationKernel::new)?;
 
     tracing::info!("Registered 6 behavioral analytics kernels");
     Ok(())

crates/rustkernel-clearing/src/lib.rs

@@ -54,24 +54,22 @@ pub use types::{
 pub fn register_all(
     registry: &rustkernel_core::registry::KernelRegistry,
 ) -> rustkernel_core::error::Result<()> {
-    use rustkernel_core::traits::GpuKernel;
-
     tracing::info!("Registering clearing kernels");
 
-    // Validation kernel (1)
-    registry.register_metadata(validation::ClearingValidation::new().metadata().clone())?;
+    // Validation kernel (1) — Batch
+    registry.register_ring_metadata_from(validation::ClearingValidation::new)?;
 
-    // DVP kernel (1)
-    registry.register_metadata(dvp::DVPMatching::new().metadata().clone())?;
+    // DVP kernel (1) — Ring
+    registry.register_ring_metadata_from(dvp::DVPMatching::new)?;
 
-    // Netting kernel (1)
-    registry.register_metadata(netting::NettingCalculation::new().metadata().clone())?;
+    // Netting kernel (1) — Batch
+    registry.register_ring_metadata_from(netting::NettingCalculation::new)?;
 
-    // Settlement kernel (1)
-    registry.register_metadata(settlement::SettlementExecution::new().metadata().clone())?;
+    // Settlement kernel (1) — Ring
+    registry.register_ring_metadata_from(settlement::SettlementExecution::new)?;
 
-    // Efficiency kernel (1)
-    registry.register_metadata(efficiency::ZeroBalanceFrequency::new().metadata().clone())?;
+    // Efficiency kernel (1) — Batch
+    registry.register_ring_metadata_from(efficiency::ZeroBalanceFrequency::new)?;
 
     tracing::info!("Registered 5 clearing kernels");
     Ok(())

crates/rustkernel-compliance/src/lib.rs

@@ -57,28 +57,26 @@ pub use sanctions::{PEPScreening, SanctionsScreening};
 pub fn register_all(
     registry: &rustkernel_core::registry::KernelRegistry,
 ) -> rustkernel_core::error::Result<()> {
-    use rustkernel_core::traits::GpuKernel;
-
     tracing::info!("Registering compliance kernels");
 
     // AML kernels (6)
-    registry.register_metadata(aml::CircularFlowRatio::new().metadata().clone())?;
-    registry.register_metadata(aml::ReciprocityFlowRatio::new().metadata().clone())?;
-    registry.register_metadata(aml::RapidMovement::new().metadata().clone())?;
-    registry.register_metadata(aml::AMLPatternDetection::new().metadata().clone())?;
-    registry.register_metadata(aml::FlowReversalPattern::new().metadata().clone())?;
-    registry.register_metadata(aml::FlowSplitRatio::new().metadata().clone())?;
+    registry.register_ring_metadata_from(aml::CircularFlowRatio::new)?;
+    registry.register_ring_metadata_from(aml::ReciprocityFlowRatio::new)?;
+    registry.register_ring_metadata_from(aml::RapidMovement::new)?;
+    registry.register_ring_metadata_from(aml::AMLPatternDetection::new)?;
+    registry.register_batch_metadata_from(aml::FlowReversalPattern::new)?;
+    registry.register_batch_metadata_from(aml::FlowSplitRatio::new)?;
 
     // KYC kernels (2)
-    registry.register_metadata(kyc::KYCScoring::new().metadata().clone())?;
-    registry.register_metadata(kyc::EntityResolution::new().metadata().clone())?;
+    registry.register_batch_typed(kyc::KYCScoring::new)?;
+    registry.register_batch_typed(kyc::EntityResolution::new)?;
 
     // Sanctions kernels (2)
-    registry.register_metadata(sanctions::SanctionsScreening::new().metadata().clone())?;
-    registry.register_metadata(sanctions::PEPScreening::new().metadata().clone())?;
+    registry.register_ring_metadata_from(sanctions::SanctionsScreening::new)?;
+    registry.register_ring_metadata_from(sanctions::PEPScreening::new)?;
 
     // Monitoring kernel (1)
-    registry.register_metadata(monitoring::TransactionMonitoring::new().metadata().clone())?;
+    registry.register_ring_metadata_from(monitoring::TransactionMonitoring::new)?;
 
     tracing::info!("Registered 11 compliance kernels");
     Ok(())

crates/rustkernel-core/src/error.rs

@@ -169,15 +169,29 @@ impl KernelError {
         KernelError::K2KError(msg.into())
     }
 
-    /// Returns true if this is a recoverable error.
+    /// Returns true if this is a recoverable error (safe to retry).
     #[must_use]
     pub fn is_recoverable(&self) -> bool {
         matches!(
             self,
             KernelError::QueueFull { .. }
                 | KernelError::QueueEmpty
                 | KernelError::Timeout(_)
+                | KernelError::ServiceUnavailable(_)
+                | KernelError::ResourceExhausted(_)
+        )
+    }
+
+    /// Returns true if this is a client error (invalid input, not found, etc.).
+    #[must_use]
+    pub fn is_client_error(&self) -> bool {
+        matches!(
+            self,
+            KernelError::KernelNotFound(_)
                 | KernelError::ValidationError(_)
+                | KernelError::DeserializationError(_)
+                | KernelError::Unauthorized(_)
+                | KernelError::DomainNotSupported(_)
         )
     }
 
@@ -186,6 +200,64 @@ impl KernelError {
     pub fn is_license_error(&self) -> bool {
         matches!(self, KernelError::LicenseError(_))
     }
+
+    /// Returns the suggested HTTP status code for this error.
+    ///
+    /// Centralizes HTTP status mapping so that all ecosystem integrations
+    /// (Axum, Tower, gRPC, Actix) use consistent status codes.
+    #[must_use]
+    pub fn http_status_code(&self) -> u16 {
+        match self {
+            KernelError::KernelNotFound(_) => 404,
+            KernelError::KernelAlreadyRegistered(_) => 409,
+            KernelError::ValidationError(_) => 400,
+            KernelError::DeserializationError(_) => 400,
+            KernelError::SerializationError(_) => 500,
+            KernelError::Unauthorized(_) => 401,
+            KernelError::ResourceExhausted(_) => 429,
+            KernelError::ServiceUnavailable(_) => 503,
+            KernelError::Timeout(_) => 504,
+            KernelError::LicenseError(_) => 403,
+            KernelError::DomainNotSupported(_) => 403,
+            KernelError::QueueFull { .. } => 503,
+            KernelError::MessageTooLarge { .. } => 413,
+            _ => 500,
+        }
+    }
+
+    /// Returns a machine-readable error code string.
+    #[must_use]
+    pub fn error_code(&self) -> &'static str {
+        match self {
+            KernelError::KernelNotFound(_) => "KERNEL_NOT_FOUND",
+            KernelError::KernelAlreadyRegistered(_) => "KERNEL_ALREADY_REGISTERED",
+            KernelError::InvalidStateTransition { .. } => "INVALID_STATE_TRANSITION",
+            KernelError::KernelNotActive(_) => "KERNEL_NOT_ACTIVE",
+            KernelError::ValidationError(_) => "VALIDATION_ERROR",
+            KernelError::SerializationError(_) => "SERIALIZATION_ERROR",
+            KernelError::DeserializationError(_) => "DESERIALIZATION_ERROR",
+            KernelError::QueueFull { .. } => "QUEUE_FULL",
+            KernelError::QueueEmpty => "QUEUE_EMPTY",
+            KernelError::MessageTooLarge { .. } => "MESSAGE_TOO_LARGE",
+            KernelError::Timeout(_) => "TIMEOUT",
+            KernelError::LaunchFailed(_) => "LAUNCH_FAILED",
+            KernelError::CompilationError(_) => "COMPILATION_ERROR",
+            KernelError::DeviceError(_) => "DEVICE_ERROR",
+            KernelError::BackendNotAvailable(_) => "BACKEND_NOT_AVAILABLE",
+            KernelError::LicenseError(_) => "LICENSE_ERROR",
+            KernelError::SLOViolation(_) => "SLO_VIOLATION",
+            KernelError::DomainNotSupported(_) => "DOMAIN_NOT_SUPPORTED",
+            KernelError::InternalError(_) => "INTERNAL_ERROR",
+            KernelError::IoError(_) => "IO_ERROR",
+            KernelError::ConfigError(_) => "CONFIG_ERROR",
+            KernelError::ActorError(_) => "ACTOR_ERROR",
+            KernelError::RingKernelError(_) => "RINGKERNEL_ERROR",
+            KernelError::K2KError(_) => "K2K_ERROR",
+            KernelError::Unauthorized(_) => "UNAUTHORIZED",
+            KernelError::ResourceExhausted(_) => "RESOURCE_EXHAUSTED",
+            KernelError::ServiceUnavailable(_) => "SERVICE_UNAVAILABLE",
+        }
+    }
 }
 
 /// Convert from ringkernel-core errors.

crates/rustkernel-core/src/lib.rs

@@ -85,8 +85,9 @@ pub mod prelude {
     pub use crate::slo::{SLOResult, SLOValidator};
     pub use crate::test_kernels::{EchoKernel, MatMul, ReduceSum, VectorAdd};
     pub use crate::traits::{
-        BatchKernel, CheckpointableKernel, DegradableKernel, ExecutionContext, GpuKernel,
-        HealthStatus, IterativeKernel, KernelConfig, RingKernelHandler, SecureRingContext,
+        BatchKernel, BatchKernelDyn, CheckpointableKernel, DegradableKernel, ExecutionContext,
+        GpuKernel, HealthStatus, IterativeKernel, KernelConfig, RingKernelDyn, RingKernelHandler,
+        SecureRingContext, TypeErasedBatchKernel, TypeErasedRingKernel,
     };
 
     // Runtime lifecycle