S203i: extract tests from 52 production files + evolve hardcoding

Massive test extraction sprint: ~10K lines of inline #[cfg(test)] mod tests
moved to companion *_tests.rs files across 22 crates. Production files >500L
reduced from 38 to 25 (remaining are pure production code without extractable
test blocks).

Hardcoding evolution:
- discovery_defaults: literal "localhost" → DEFAULT_HOSTNAME constant
- dispatch submit/shader_dispatch: CORALREEF_URL refs → capability-neutral guidance

Made-with: Cursor

Author: westgate

CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased] - April 14, 2026 (Sessions 43-203)
 
+### Session S203i (Apr 14, 2026) — Deep Debt: Massive Test Extraction + Hardcoding Evolution
+
+#### Smart File Refactoring (52 production files — test extraction)
+- EXTRACTED: inline `#[cfg(test)] mod tests { ... }` blocks from 52 production files into companion `*_tests.rs` files
+- Pattern: `#[cfg(test)] #[path = "{name}_tests.rs"] mod tests;` — consistent with repo convention
+- Affected crates: `core/config`, `core/common`, `core/toadstool`, `core/nvpmu`, `core/sysmon`, `toadstool-core`, `server`, `cli`, `auto_config`, `distributed`, `integration/protocols`, `integration/security`, `management/performance`, `runtime/container`, `runtime/orchestration`, `runtime/specialty`, `runtime/display`, `runtime/secure_enclave`, `runtime/gpu`, `security/sandbox`, `neuromorphic/akida-driver`, `ml/burn-inference`
+- Total test lines extracted: ~10,000+ lines moved from production files to dedicated test files
+- 25 production files remain >500 lines (pure production code — hardware drivers, type definitions, crypto managers — no extractable test blocks)
+
+#### Hardcoding Evolution
+- EVOLVED: `FallbackEndpoints::fallback_endpoint()` — replaced literal `"localhost"` with `DEFAULT_HOSTNAME` constant
+- EVOLVED: `dispatch_submit` note — removed hardcoded `CORALREEF_URL` reference, replaced with capability-neutral guidance
+- EVOLVED: `shader_dispatch` note — removed hardcoded `CORALREEF_URL / CORALREEF_SOCKET` reference, replaced with capability-neutral guidance
+
 ### Session S203h (Apr 14, 2026) — benchScale: TCP Idle Timeout (primalSpring exp082)
 
 #### TCP Idle Timeout (benchScale finding)

DEBT.md

@@ -1,6 +1,6 @@
 # Active Technical Debt Register
 
-**Date**: April 14, 2026 — S203h
+**Date**: April 14, 2026 — S203i
 **Philosophy**: Math is universal, precision is silicon. Workarounds are
 short-term solutions that increase debt. We aim to solve deep debt over
 iterations, evolving toward vendor-agnostic, capability-based solutions.
@@ -64,6 +64,19 @@ dependency is pure Rust (proc-macro) and zero-overhead at runtime for non-dyn pa
 
 ## S203 Resolved Debt (Deep Audit & Evolution Execution)
 
+### D-LARGE-FILE-REFACTOR-S203I — RESOLVED S203i
+**Scope**: 52 production files across 22 crates
+Massive test extraction sprint: inline `#[cfg(test)] mod tests { ... }` blocks extracted to
+companion `*_tests.rs` files. ~10,000+ lines of test code moved out of production modules.
+Production file count over 500 lines reduced from 38 to 25 (remaining files are pure production
+code — hardware drivers, type definitions, crypto managers — with no extractable test blocks).
+
+### D-HARDCODING-CORALREEF-NOTES-S203I — RESOLVED S203i
+**Scope**: `server/dispatch/submit.rs`, `server/dispatch/shader_dispatch.rs`
+Dispatch error metadata replaced hardcoded `CORALREEF_URL` / `CORALREEF_SOCKET` env var names
+with capability-neutral guidance. Also: `discovery_defaults.rs` literal `"localhost"` replaced
+with `DEFAULT_HOSTNAME` constant.
+
 ### D-LARGE-FILE-REFACTOR-S203G — RESOLVED S203g
 **Scope**: 12 files across 8 crates
 Smart test extraction from production files >540 LOC. Same pattern as S203c/S203e.

README.md

@@ -58,7 +58,7 @@ Nest    = Tower  + Storage            <- storage
 | Hardcoded ports/localhost | 0 inline literals -- config constants + capability-based discovery |
 | Hardware transport | Implemented | DRM display, V4L2 capture, serial — frame protocol + router |
 | License | AGPL-3.0-or-later -- root LICENSE file + SPDX headers on all files |
-| File size limit | All production files **< 500 lines** (S203g: 26 large modules refactored via test extraction across S203c/e/g; all production files target <500 lines) |
+| File size limit | All production files target **< 500 lines** (S203i: 52 production files refactored via test extraction across S203c/e/g/i; 25 files remain >500 lines — pure production code with no extractable test blocks, all <700 lines) |
 | Test concurrency | Unlimited parallelism (removed global throttle); zero `#[serial]`; test-time mDNS/TCP timeouts via `cfg!(test)`; zero fixed sleeps in non-chaos tests |
 | Environment safety | All env-var tests use `temp_env` (thread-safe), zero `std::env::set_var` in tests |
 
@@ -271,6 +271,8 @@ toadStool/
 - **Sovereign compiler Phase 4+** -- register pressure estimation, loop software pipelining (barraCuda)
 
 ### Recently Completed
+- **S203i (Apr 14, 2026)**: Deep debt — 52 production files refactored via test extraction (~10K+ lines moved to companion files). Hardcoding evolution: `CORALREEF_URL`/`CORALREEF_SOCKET` references replaced with capability-neutral guidance; literal `localhost` in `FallbackEndpoints` replaced with `DEFAULT_HOSTNAME` constant. Production files >500L reduced from 38→25.
+- **S203h (Apr 14, 2026)**: TCP idle timeout — `TCP_IDLE_TIMEOUT_SECS` (300s configurable), `tokio::time::timeout` wraps on all TCP read loops (JSON-RPC + tarpc), `TCP_NODELAY` on all accepted streams. Resolves primalSpring benchScale exp082.
 - **S203g (Apr 13, 2026)**: Deep debt — 12 production files >540 LOC refactored via test extraction. 6 deprecated zero-caller items removed (`localhost_endpoint`, `METRICS_PORT`, `capability_typical_provider` module, `get_primal_default_port` wrappers, `TarpcClient::address()`). Blocking `thread::sleep` in async GPU discovery evolved to `tokio::oneshot` + `tokio::time::timeout`. Forward dispatch clone optimization.
 - **S203f (Apr 13, 2026)**: wetSpring V143 validation — `compute.execute` promoted to direct JSON-RPC route (PG-05 gap). Pipeline methods added to `capabilities.list`. plasmidBin metadata expanded to 46 callable methods.
 - **S203e (Apr 12, 2026)**: Deep debt — 8 hardcoded network constants centralized to `core/config/defaults/network.rs`. 5 production files refactored via test extraction. Full deep audit: zero TODO/FIXME/HACK/dbg/unwrap/set_var in production.

crates/auto_config/src/ai_mcp_interface/mod.rs

@@ -209,321 +209,5 @@ impl AiMcpInterface {
 // =============================================================================
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use std::collections::HashMap;
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_intelligence_mcp_interface_creation() {
-        let interface = AiMcpInterface::new();
-        assert!(interface.is_ok());
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    #[cfg_attr(
-        not(feature = "slow-tests"),
-        ignore = "slow integration test - runs full NL processing and hardware detection"
-    )]
-    async fn test_natural_language_config_request() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let request = McpRequest {
-            request_id: "test-001".to_string(),
-            session_id: None,
-            agent_id: "test-agent".to_string(),
-            request_type: McpRequestType::NaturalLanguageConfig {
-                instruction: "Enable high performance mode".to_string(),
-            },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await;
-
-        assert!(
-            response.is_ok(),
-            "AI request should succeed: {:?}",
-            response.as_ref().err()
-        );
-        let result = response.unwrap();
-        assert!(result.success, "Should return success response");
-        assert!(
-            !result.message.is_empty(),
-            "Should return non-empty message"
-        );
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_natural_language_config_request_fast() {
-        // Fast test that checks interface state without full NL pipeline
-        let interface = AiMcpInterface::new().unwrap();
-
-        // This should be fast as it only checks interface state
-        let stats = interface.get_session_stats().await;
-        assert!(!stats.is_empty(), "Should return stats");
-
-        // Verify expected keys exist
-        assert!(stats.contains_key("active_sessions"));
-        assert!(stats.contains_key("total_requests"));
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_intelligence_mcp_context_handling() {
-        let interface = AiMcpInterface::new().unwrap();
-        let stats = interface.get_session_stats().await;
-
-        // Check that stats are returned and active sessions is 0
-        assert!(!stats.is_empty(), "Should return stats");
-        if let Some(serde_json::Value::Number(n)) = stats.get("active_sessions") {
-            assert_eq!(
-                n.as_u64().unwrap(),
-                0,
-                "Should start with no active sessions"
-            );
-        } else {
-            unreachable!("active_sessions key not found or wrong type");
-        }
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_create_session() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let request = McpRequest {
-            request_id: "create-session-001".to_string(),
-            session_id: None,
-            agent_id: "test-agent".to_string(),
-            request_type: McpRequestType::CreateSession { preferences: None },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await.unwrap();
-        assert!(response.success);
-        assert!(response.message.contains("session created"));
-        assert!(response.session_info.is_some());
-        let session_info = response.session_info.unwrap();
-        assert!(!session_info.session_id.is_empty());
-        assert_eq!(session_info.status, "Active");
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_create_session_with_preferences() {
-        let mut interface = AiMcpInterface::new().unwrap();
-        let prefs = AiPreferences::default();
-
-        let request = McpRequest {
-            request_id: "create-002".to_string(),
-            session_id: None,
-            agent_id: "agent-2".to_string(),
-            request_type: McpRequestType::CreateSession {
-                preferences: Some(prefs),
-            },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await.unwrap();
-        assert!(response.success);
-        assert!(response.session_info.is_some());
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_update_preferences_session_not_found() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let request = McpRequest {
-            request_id: "update-001".to_string(),
-            session_id: Some("nonexistent-session".to_string()),
-            agent_id: "agent".to_string(),
-            request_type: McpRequestType::UpdatePreferences {
-                preferences: AiPreferences::default(),
-            },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await.unwrap();
-        assert!(!response.success);
-        assert!(response.message.contains("Session not found"));
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_update_preferences_success() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        // First create a session
-        let create_req = McpRequest {
-            request_id: "create".to_string(),
-            session_id: None,
-            agent_id: "agent".to_string(),
-            request_type: McpRequestType::CreateSession { preferences: None },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-        let create_resp = interface.process_ai_request(create_req).await.unwrap();
-        let session_id = create_resp
-            .session_info
-            .as_ref()
-            .unwrap()
-            .session_id
-            .clone();
-
-        // Now update preferences
-        let prefs = AiPreferences::default();
-        let request = McpRequest {
-            request_id: "update".to_string(),
-            session_id: Some(session_id),
-            agent_id: "agent".to_string(),
-            request_type: McpRequestType::UpdatePreferences {
-                preferences: prefs.clone(),
-            },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await.unwrap();
-        assert!(response.success);
-        assert!(response.message.contains("Preferences updated"));
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_get_system_status() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let request = McpRequest {
-            request_id: "status-001".to_string(),
-            session_id: None,
-            agent_id: "agent".to_string(),
-            request_type: McpRequestType::GetSystemStatus,
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await.unwrap();
-        assert!(response.success);
-        assert!(response.data.is_some());
-        let data = response.data.unwrap();
-        assert!(data.get("hardware").is_some());
-        assert!(data.get("ecosystem").is_some());
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_optimize_for_task() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let request = McpRequest {
-            request_id: "optimize-001".to_string(),
-            session_id: None,
-            agent_id: "agent".to_string(),
-            request_type: McpRequestType::OptimizeForTask {
-                task_description: "run machine learning training".to_string(),
-            },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await.unwrap();
-        assert!(response.success);
-        assert!(response.config_applied.is_some());
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_execute_with_intent() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let request = McpRequest {
-            request_id: "execute-001".to_string(),
-            session_id: None,
-            agent_id: "agent".to_string(),
-            request_type: McpRequestType::ExecuteWithIntent {
-                code: "print('hello')".to_string(),
-                intent: ExecutionIntent {
-                    purpose: "test execution".to_string(),
-                    security_requirements: vec![],
-                    performance_expectations: PerformanceExpectations {
-                        expected_duration: None,
-                        cpu_intensity: 0.5,
-                        memory_pattern: MemoryPattern::Normal,
-                        io_intensity: IoIntensity::Low,
-                    },
-                    resource_hints: ResourceHints {
-                        cpu_cores: None,
-                        memory_gb: None,
-                        gpu_required: false,
-                        storage_gb: None,
-                    },
-                    runtime_hint: None,
-                },
-            },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-
-        let response = interface.process_ai_request(request).await.unwrap();
-        assert!(response.success);
-        assert!(response.config_applied.is_some());
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_increments_counter() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let request = McpRequest {
-            request_id: "req-1".to_string(),
-            session_id: None,
-            agent_id: "agent".to_string(),
-            request_type: McpRequestType::GetSystemStatus,
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-        let _ = interface.process_ai_request(request).await.unwrap();
-
-        let stats = interface.get_session_stats().await;
-        let total = stats
-            .get("total_requests")
-            .and_then(serde_json::Value::as_u64)
-            .unwrap_or(0);
-        assert!(total >= 1);
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-    async fn test_process_ai_request_updates_session_activity() {
-        let mut interface = AiMcpInterface::new().unwrap();
-
-        let create_req = McpRequest {
-            request_id: "c1".to_string(),
-            session_id: None,
-            agent_id: "a".to_string(),
-            request_type: McpRequestType::CreateSession { preferences: None },
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-        let create_resp = interface.process_ai_request(create_req).await.unwrap();
-        let session_id = create_resp
-            .session_info
-            .as_ref()
-            .unwrap()
-            .session_id
-            .clone();
-
-        let status_req = McpRequest {
-            request_id: "s1".to_string(),
-            session_id: Some(session_id.clone()),
-            agent_id: "a".to_string(),
-            request_type: McpRequestType::GetSystemStatus,
-            metadata: HashMap::new(),
-            timestamp: SystemTime::now(),
-        };
-        let _ = interface.process_ai_request(status_req).await.unwrap();
-
-        let stats = interface.get_session_stats().await;
-        assert!(
-            stats
-                .get("active_sessions")
-                .and_then(serde_json::Value::as_u64)
-                .unwrap_or(0)
-                >= 1
-        );
-    }
-}
+#[path = "mod_tests.rs"]
+mod tests;