diff --git a/meshchatx/src/backend/recovery/crash_recovery.py b/meshchatx/src/backend/recovery/crash_recovery.py index 709c46e..b00309c 100644 --- a/meshchatx/src/backend/recovery/crash_recovery.py +++ b/meshchatx/src/backend/recovery/crash_recovery.py @@ -1,11 +1,10 @@ """CRASH RECOVERY & ADAPTIVE DIAGNOSTIC ENGINE -------------------------------------------------- -Mathematically grounded diagnostic system for MeshChatX. +Diagnostic system for MeshChatX. Uses Shannon Entropy, KL-Divergence, and Bayesian weight learning -to map application failures onto deterministic manifold constraints. -Crash history is persisted and priors are refined over time using -a conjugate Beta-Binomial model. +to diagnose application failures. Crash history is persisted and +priors are refined over time using a conjugate Beta-Binomial model. """ import contextlib @@ -213,18 +212,13 @@ class CrashRecovery: except Exception as e: out.write(f" [ERROR] Failed to complete diagnosis: {e}\n") - # Enhanced Explanation Engine (Analytic logic) - out.write("\nProbabilistic Root Cause Analysis:\n") + out.write("\nRoot Cause Analysis:\n") causes = self._analyze_cause(exc_type, exc_value, diagnosis_results) - # Calculate advanced system state metrics entropy, divergence = self._calculate_system_entropy(diagnosis_results) - curvature = self._calculate_manifold_curvature(causes) out.write(f" [System Entropy: {entropy:.4f} bits]\n") - out.write(f" [Systemic Divergence (KL): {divergence:.4f} bits]\n") - out.write(f" [Manifold Curvature: {curvature:.2f}κ]\n") - out.write(" [Deterministic Manifold Constraints: V1,V4 Active]\n") + out.write(f" [KL-Divergence: {divergence:.4f} bits]\n") if self.log_handler: log_ent = self.log_handler.current_log_entropy @@ -277,7 +271,7 @@ class CrashRecovery: sys.exit(1) def _analyze_cause(self, exc_type, exc_value, diagnosis): - """Uses probabilistic active inference and heuristic pattern matching + """Uses heuristic pattern matching and Bayesian priors to determine the likely root cause of the application crash. """ causes = [] @@ -470,21 +464,6 @@ class CrashRecovery: causes.sort(key=lambda x: x["probability"], reverse=True) - # Apply Mathematical Grounding via Active Inference Directives if possible - if causes: - # We "ground" the top cause - top_cause = causes[0] - if top_cause["probability"] > 90: - top_cause["reasoning"] += ( - " This diagnosis has reached a high-confidence threshold grounded in " - "deterministic manifold constraints (V1,V4) and active inference." - ) - else: - top_cause["reasoning"] += ( - " This diagnosis is based on probabilistic heuristic matching of " - "current system entropy against known failure manifolds." - ) - return causes def _calculate_system_entropy(self, diagnosis): @@ -547,23 +526,6 @@ class CrashRecovery: return entropy, divergence - def _calculate_manifold_curvature(self, causes): - """Calculates 'Manifold Curvature' (κ) based on the gradient of probabilities. - High curvature indicates a 'sharp' failure where one cause is dominant. - Low curvature indicates an 'ambiguous' failure landscape. - """ - if not causes: - return 0.0 - - probs = [c["probability"] / 100.0 for c in causes] - if len(probs) < 2: - # If there's only one cause and it's high probability, curvature is high - return probs[0] * 10.0 - - # Curvature is the 'steepness' between the top two causes - gradient = probs[0] - probs[1] - return gradient * 10.0 - def run_diagnosis(self, file=sys.stderr): """Performs a series of OS-agnostic checks on the application's environment.""" results = { diff --git a/tests/backend/test_crash_recovery.py b/tests/backend/test_crash_recovery.py index a1c50d6..03109f4 100644 --- a/tests/backend/test_crash_recovery.py +++ b/tests/backend/test_crash_recovery.py @@ -120,7 +120,7 @@ class TestCrashRecovery(unittest.TestCase): self.assertIn("!!! APPLICATION CRASH DETECTED !!!", report) self.assertIn("Type: ValueError", report) self.assertIn("Message: Simulated error for testing", report) - self.assertIn("Probabilistic Root Cause Analysis:", report) + self.assertIn("Root Cause Analysis:", report) self.assertIn("Recovery Suggestions:", report) def test_heuristic_analysis_sqlite(self): @@ -164,10 +164,6 @@ class TestCrashRecovery(unittest.TestCase): causes = self.recovery._analyze_cause(exc_type, exc_value, diagnosis) self.assertEqual(causes[0]["description"], "Missing Reticulum Configuration") self.assertEqual(causes[0]["probability"], 99) - self.assertIn( - "deterministic manifold constraints", - causes[0]["reasoning"].lower(), - ) def test_entropy_calculation_levels(self): """Test how entropy reflects system disorder.""" @@ -201,27 +197,6 @@ class TestCrashRecovery(unittest.TestCase): # Actually for a "disorder" metric, we might want it to peak when things are most uncertain. # But in our context, we are showing entropy of the "State Predictability". - def test_confidence_grounding_text(self): - """Verify that reasoning text reflects grounding logic.""" - # High confidence scenario - exc_type = RuntimeError - exc_value = RuntimeError("no current event loop") - diagnosis = {} # probability 88% -> heuristic matching - causes_low = self.recovery._analyze_cause(exc_type, exc_value, diagnosis) - self.assertIn( - "probabilistic heuristic matching", - causes_low[0]["reasoning"].lower(), - ) - - # Near-certainty scenario - diagnosis_certain = {"config_missing": True} - causes_high = self.recovery._analyze_cause( - exc_type, - exc_value, - diagnosis_certain, - ) - self.assertIn("high-confidence threshold", causes_high[0]["reasoning"].lower()) - def test_heuristic_analysis_lxmf_storage(self): """Test LXMF storage failure detection.""" exc_type = RuntimeError @@ -280,8 +255,7 @@ class TestCrashRecovery(unittest.TestCase): report = output.getvalue() self.assertIn("[System Entropy:", report) - self.assertIn("[Deterministic Manifold Constraints:", report) - self.assertIn("deterministic manifold constraints", report.lower()) + self.assertIn("[KL-Divergence:", report) def test_heuristic_analysis_unsupported_python(self): """Test detection of unsupported Python versions.""" @@ -344,38 +318,6 @@ class TestCrashRecovery(unittest.TestCase): finally: sys.excepthook = original - # ================================================================== - # _calculate_manifold_curvature - # ================================================================== - - def test_curvature_empty_causes(self): - """Empty causes list should return 0.0 curvature.""" - self.assertEqual(self.recovery._calculate_manifold_curvature([]), 0.0) - - def test_curvature_single_cause(self): - """Single cause should return probability * 10.""" - causes = [{"probability": 95}] - self.assertAlmostEqual(self.recovery._calculate_manifold_curvature(causes), 9.5) - - def test_curvature_two_causes_gradient(self): - """Curvature should be 10 * (top - second).""" - causes = [{"probability": 90}, {"probability": 40}] - self.assertAlmostEqual(self.recovery._calculate_manifold_curvature(causes), 5.0) - - def test_curvature_equal_causes(self): - """Equal probabilities should give curvature = 0.""" - causes = [{"probability": 50}, {"probability": 50}] - self.assertAlmostEqual(self.recovery._calculate_manifold_curvature(causes), 0.0) - - def test_curvature_many_causes(self): - """Only top 2 probabilities matter for curvature.""" - causes = [ - {"probability": 80}, - {"probability": 30}, - {"probability": 10}, - ] - self.assertAlmostEqual(self.recovery._calculate_manifold_curvature(causes), 5.0) - # ================================================================== # _calculate_system_entropy edge cases # ================================================================== diff --git a/tests/backend/test_property_based.py b/tests/backend/test_property_based.py index d51e6c7..8276212 100644 --- a/tests/backend/test_property_based.py +++ b/tests/backend/test_property_based.py @@ -998,22 +998,6 @@ class TestCrashRecoveryMathProperties: assert entropy >= 0, f"Negative entropy: {entropy}" assert divergence >= 0, f"Negative divergence: {divergence}" - @given( - probs=st.lists( - st.integers(min_value=0, max_value=100), min_size=0, max_size=10 - ), - ) - @settings(derandomize=True, deadline=None) - def test_manifold_curvature_bounded(self, probs): - """Manifold curvature must always be a non-negative finite float.""" - import math as m - - recovery = self._make_recovery() - causes = [{"probability": p} for p in probs] - curvature = recovery._calculate_manifold_curvature(causes) - assert m.isfinite(curvature), f"Non-finite curvature: {curvature}" - assert curvature >= 0 or len(probs) >= 2, f"Unexpected negative: {curvature}" - @given( exc_msg=st.text(min_size=0, max_size=200), exc_type_name=st.sampled_from(