Phase 7: Complete stub implementations and algorithm upgrades

Phase 7.1-7.2 (Infrastructure & Ring Handlers):
- Implement register_all() for all 14 domain crates with proper kernel registration
- Complete KernelMessage derive macro with full RingMessage trait generation
- Add state management to Ring kernels (PageRank, KMeans, VaR, GARCH, AML)
- Implement Ring handlers with internal state using RwLock pattern

Phase 7.3 (Financial Algorithms):
- Implement full Black-Scholes option pricing with proper N(d1), N(d2)
- Add delta-gamma VaR model for hedge effectiveness in FX hedging
- Improve swap duration calculation with fixed vs floating leg analysis
- Upgrade LCR improvement calculation to simulate actions and recalculate
- Add proper days-until-breach liquidity runoff model

Phase 7.4 (Statistical Algorithms):
- Upgrade MA coefficient estimation from autocorrelation to CSS optimization
- Implement proper Student's t-distribution p-value using regularized
  incomplete beta function with Lanczos log-gamma approximation

Phase 7.5 (Business Logic):
- Fix currency extraction in netting to use trade attributes
- Implement full business hours processing with timezone support
- Add configurable business hours start/end and timezone offset

All 610 tests pass.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mivertowski

Cargo.lock

@@ -178,17 +178,15 @@ impl ChartOfAccountsMapping {
                     amount_ratio: 1.0,
                 }]
             }
-            MappingTransformation::Split(splits) => {
-                splits
-                    .iter()
-                    .map(|(target, ratio)| MappedAccount {
-                        source_code: account.code.clone(),
-                        target_code: target.clone(),
-                        rule_id: rule.id.clone(),
-                        amount_ratio: *ratio,
-                    })
-                    .collect()
-            }
+            MappingTransformation::Split(splits) => splits
+                .iter()
+                .map(|(target, ratio)| MappedAccount {
+                    source_code: account.code.clone(),
+                    target_code: target.clone(),
+                    rule_id: rule.id.clone(),
+                    amount_ratio: *ratio,
+                })
+                .collect(),
             MappingTransformation::Aggregate => {
                 vec![MappedAccount {
                     source_code: account.code.clone(),
@@ -197,7 +195,11 @@ impl ChartOfAccountsMapping {
                     amount_ratio: 1.0,
                 }]
             }
-            MappingTransformation::Conditional { condition, if_true, if_false } => {
+            MappingTransformation::Conditional {
+                condition,
+                if_true,
+                if_false,
+            } => {
                 let target = if Self::evaluate_condition(account, condition) {
                     if_true.clone()
                 } else {
@@ -253,7 +255,9 @@ impl ChartOfAccountsMapping {
             }
 
             // Check for empty targets
-            if rule.target_code.is_empty() && !matches!(rule.transformation, MappingTransformation::Split(_)) {
+            if rule.target_code.is_empty()
+                && !matches!(rule.transformation, MappingTransformation::Split(_))
+            {
                 errors.push(RuleValidationError {
                     rule_id: rule.id.clone(),
                     message: "Target code is empty".to_string(),
@@ -443,7 +447,8 @@ mod tests {
             ]),
         }];
 
-        let result = ChartOfAccountsMapping::map_accounts(&accounts, &rules, &MappingConfig::default());
+        let result =
+            ChartOfAccountsMapping::map_accounts(&accounts, &rules, &MappingConfig::default());
 
         assert_eq!(result.mapped.len(), 2);
         assert!((result.mapped[0].amount_ratio - 0.6).abs() < 0.001);
@@ -484,7 +489,8 @@ mod tests {
             transformation: MappingTransformation::Direct,
         }];
 
-        let result = ChartOfAccountsMapping::map_accounts(&accounts, &rules, &MappingConfig::default());
+        let result =
+            ChartOfAccountsMapping::map_accounts(&accounts, &rules, &MappingConfig::default());
 
         assert_eq!(result.stats.mapped_count, 1);
         assert_eq!(result.unmapped.len(), 1);
@@ -561,7 +567,8 @@ mod tests {
         let rules = create_test_rules();
 
         // Default: exclude inactive
-        let result1 = ChartOfAccountsMapping::map_accounts(&accounts, &rules, &MappingConfig::default());
+        let result1 =
+            ChartOfAccountsMapping::map_accounts(&accounts, &rules, &MappingConfig::default());
         assert_eq!(result1.stats.total_accounts, 0);
 
         // Include inactive

crates/rustkernel-accounting/src/coa_mapping.rs

@@ -54,10 +54,8 @@ impl JournalTransformation {
         let mut total_credit = 0.0;
 
         // Build mapping lookup
-        let mapping_lookup: HashMap<String, Vec<&MappedAccount>> = mapping
-            .mapped
-            .iter()
-            .fold(HashMap::new(), |mut acc, m| {
+        let mapping_lookup: HashMap<String, Vec<&MappedAccount>> =
+            mapping.mapped.iter().fold(HashMap::new(), |mut acc, m| {
                 acc.entry(m.source_code.clone()).or_default().push(m);
                 acc
             });
@@ -261,7 +259,8 @@ impl JournalTransformation {
 
         // Count distinct entries per account
         for entry in entries {
-            let mut seen_accounts: std::collections::HashSet<&str> = std::collections::HashSet::new();
+            let mut seen_accounts: std::collections::HashSet<&str> =
+                std::collections::HashSet::new();
             for line in &entry.lines {
                 if seen_accounts.insert(&line.account_code) {
                     if let Some(summary) = summaries.get_mut(&line.account_code) {
@@ -504,7 +503,12 @@ mod tests {
 
         // Should preserve unmapped 4000 account
         assert_eq!(result.stats.transformed_count, 1);
-        assert!(result.entries[0].lines.iter().any(|l| l.account_code == "4000"));
+        assert!(
+            result.entries[0]
+                .lines
+                .iter()
+                .any(|l| l.account_code == "4000")
+        );
     }
 
     #[test]
@@ -541,12 +545,17 @@ mod tests {
             },
         };
 
-        let result = JournalTransformation::transform(&entries, &mapping, &TransformConfig::default());
+        let result =
+            JournalTransformation::transform(&entries, &mapping, &TransformConfig::default());
 
         // Should have 3 lines (1000 split to 2, 4000 to 1)
         assert_eq!(result.entries[0].lines.len(), 3);
 
-        let a1001_line = result.entries[0].lines.iter().find(|l| l.account_code == "A1001").unwrap();
+        let a1001_line = result.entries[0]
+            .lines
+            .iter()
+            .find(|l| l.account_code == "A1001")
+            .unwrap();
         assert!((a1001_line.debit - 600.0).abs() < 0.01);
     }
 

crates/rustkernel-accounting/src/journal.rs

@@ -11,21 +11,59 @@
 
 #![warn(missing_docs)]
 
-pub mod types;
 pub mod coa_mapping;
 pub mod journal;
-pub mod reconciliation;
 pub mod network;
+pub mod reconciliation;
 pub mod temporal;
+pub mod types;
 
 pub use coa_mapping::ChartOfAccountsMapping;
 pub use journal::JournalTransformation;
-pub use reconciliation::GLReconciliation;
 pub use network::NetworkAnalysis;
+pub use reconciliation::GLReconciliation;
 pub use temporal::TemporalCorrelation;
 
 /// Register all accounting kernels.
-pub fn register_all(_registry: &rustkernel_core::registry::KernelRegistry) -> rustkernel_core::error::Result<()> {
+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(),
+    )?;
+
+    // Journal kernel (1)
+    registry.register_metadata(journal::JournalTransformation::new().metadata().clone())?;
+
+    // Reconciliation kernel (1)
+    registry.register_metadata(reconciliation::GLReconciliation::new().metadata().clone())?;
+
+    // Network kernel (1)
+    registry.register_metadata(network::NetworkAnalysis::new().metadata().clone())?;
+
+    // Temporal kernel (1)
+    registry.register_metadata(temporal::TemporalCorrelation::new().metadata().clone())?;
+
+    tracing::info!("Registered 5 accounting kernels");
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rustkernel_core::registry::KernelRegistry;
+
+    #[test]
+    fn test_register_all() {
+        let registry = KernelRegistry::new();
+        register_all(&registry).expect("Failed to register accounting kernels");
+        assert_eq!(registry.total_count(), 5);
+    }
+}

crates/rustkernel-accounting/src/lib.rs

@@ -6,9 +6,8 @@
 //! - Generate elimination entries
 
 use crate::types::{
-    CircularReference, EliminationEntry, EntityBalance, EntityRelationship,
-    IntercompanyStatus, IntercompanyTransaction, IntercompanyType, NetworkAnalysisResult,
-    NetworkStats,
+    CircularReference, EliminationEntry, EntityBalance, EntityRelationship, IntercompanyStatus,
+    IntercompanyTransaction, IntercompanyType, NetworkAnalysisResult, NetworkStats,
 };
 use rustkernel_core::{domain::Domain, kernel::KernelMetadata, traits::GpuKernel};
 use std::collections::{HashMap, HashSet};
@@ -94,27 +93,29 @@ impl NetworkAnalysis {
             }
 
             // From entity has a receivable
-            let from_balance = balances.entry(txn.from_entity.clone()).or_insert_with(|| {
-                EntityBalance {
-                    entity_id: txn.from_entity.clone(),
-                    total_receivables: 0.0,
-                    total_payables: 0.0,
-                    net_position: 0.0,
-                    counterparty_count: 0,
-                }
-            });
+            let from_balance =
+                balances
+                    .entry(txn.from_entity.clone())
+                    .or_insert_with(|| EntityBalance {
+                        entity_id: txn.from_entity.clone(),
+                        total_receivables: 0.0,
+                        total_payables: 0.0,
+                        net_position: 0.0,
+                        counterparty_count: 0,
+                    });
             from_balance.total_receivables += txn.amount;
 
             // To entity has a payable
-            let to_balance = balances.entry(txn.to_entity.clone()).or_insert_with(|| {
-                EntityBalance {
-                    entity_id: txn.to_entity.clone(),
-                    total_receivables: 0.0,
-                    total_payables: 0.0,
-                    net_position: 0.0,
-                    counterparty_count: 0,
-                }
-            });
+            let to_balance =
+                balances
+                    .entry(txn.to_entity.clone())
+                    .or_insert_with(|| EntityBalance {
+                        entity_id: txn.to_entity.clone(),
+                        total_receivables: 0.0,
+                        total_payables: 0.0,
+                        net_position: 0.0,
+                        counterparty_count: 0,
+                    });
             to_balance.total_payables += txn.amount;
         }
 
@@ -166,15 +167,15 @@ impl NetworkAnalysis {
                 (txn.to_entity.clone(), txn.from_entity.clone())
             };
 
-            let rel = relationships.entry(key.clone()).or_insert_with(|| {
-                EntityRelationship {
+            let rel = relationships
+                .entry(key.clone())
+                .or_insert_with(|| EntityRelationship {
                     from_entity: key.0.clone(),
                     to_entity: key.1.clone(),
                     total_volume: 0.0,
                     transaction_count: 0,
                     net_balance: 0.0,
-                }
-            });
+                });
 
             rel.total_volume += txn.amount;
             rel.transaction_count += 1;
@@ -259,7 +260,10 @@ impl NetworkAnalysis {
                         .windows(2)
                         .filter_map(|w| {
                             graph.get(&w[0]).and_then(|edges| {
-                                edges.iter().find(|(to, _)| to == &w[1]).map(|(_, amt)| *amt)
+                                edges
+                                    .iter()
+                                    .find(|(to, _)| to == &w[1])
+                                    .map(|(_, amt)| *amt)
                             })
                         })
                         .sum();
@@ -298,7 +302,8 @@ impl NetworkAnalysis {
                 continue;
             }
 
-            let (debit_account, credit_account) = Self::get_elimination_accounts(&txn.transaction_type);
+            let (debit_account, credit_account) =
+                Self::get_elimination_accounts(&txn.transaction_type);
 
             eliminations.push(EliminationEntry {
                 id: format!("ELIM{:05}", entry_id),
@@ -320,18 +325,30 @@ impl NetworkAnalysis {
     fn get_elimination_accounts(txn_type: &IntercompanyType) -> (String, String) {
         match txn_type {
             IntercompanyType::Trade => ("IC_PAYABLES".to_string(), "IC_RECEIVABLES".to_string()),
-            IntercompanyType::Loan => ("IC_LOAN_PAYABLE".to_string(), "IC_LOAN_RECEIVABLE".to_string()),
-            IntercompanyType::Dividend => ("DIVIDEND_INCOME".to_string(), "DIVIDEND_EXPENSE".to_string()),
-            IntercompanyType::ManagementFee => ("MGMT_FEE_INCOME".to_string(), "MGMT_FEE_EXPENSE".to_string()),
-            IntercompanyType::Royalty => ("ROYALTY_INCOME".to_string(), "ROYALTY_EXPENSE".to_string()),
-            IntercompanyType::Other => ("IC_OTHER_PAYABLE".to_string(), "IC_OTHER_RECEIVABLE".to_string()),
+            IntercompanyType::Loan => (
+                "IC_LOAN_PAYABLE".to_string(),
+                "IC_LOAN_RECEIVABLE".to_string(),
+            ),
+            IntercompanyType::Dividend => (
+                "DIVIDEND_INCOME".to_string(),
+                "DIVIDEND_EXPENSE".to_string(),
+            ),
+            IntercompanyType::ManagementFee => (
+                "MGMT_FEE_INCOME".to_string(),
+                "MGMT_FEE_EXPENSE".to_string(),
+            ),
+            IntercompanyType::Royalty => {
+                ("ROYALTY_INCOME".to_string(), "ROYALTY_EXPENSE".to_string())
+            }
+            IntercompanyType::Other => (
+                "IC_OTHER_PAYABLE".to_string(),
+                "IC_OTHER_RECEIVABLE".to_string(),
+            ),
         }
     }
 
     /// Calculate netting opportunities.
-    pub fn calculate_netting(
-        transactions: &[IntercompanyTransaction],
-    ) -> Vec<NettingOpportunity> {
+    pub fn calculate_netting(transactions: &[IntercompanyTransaction]) -> Vec<NettingOpportunity> {
         let mut opportunities = Vec::new();
 
         // Find bilateral netting opportunities
@@ -550,9 +567,10 @@ mod tests {
         assert!(!result.elimination_entries.is_empty());
 
         // Check trade elimination
-        let trade_elim = result.elimination_entries.iter().find(|e| {
-            e.from_entity == "CORP_A" && e.to_entity == "CORP_B"
-        });
+        let trade_elim = result
+            .elimination_entries
+            .iter()
+            .find(|e| e.from_entity == "CORP_A" && e.to_entity == "CORP_B");
         assert!(trade_elim.is_some());
     }