margin 0.9.1__tar.gz → 0.9.3__tar.gz

{margin-0.9.1/margin.egg-info → margin-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.1
+Version: 0.9.3
 Summary: Typed health classification, uncertainty algebra, and correction auditing for any system that measures things and needs to explain what happened.
 Author: Cope Labs LLC
 License: MIT

{margin-0.9.1 → margin-0.9.3}/margin/health.py

@@ -46,6 +46,7 @@ class Thresholds:
                       (throughput, signal), False means lower values are
                       healthier (error rate, latency)
     active_min:       minimum correction magnitude to count as "active"
+    labels:           optional display labels keyed by Health.value strings
 
     For higher_is_better=True:  intact >= ablated, value >= intact → INTACT
     For higher_is_better=False: intact <= ablated, value <= intact → INTACT
@@ -54,6 +55,36 @@ class Thresholds:
     ablated: float
     higher_is_better: bool = True
     active_min: float = 0.05
+    labels: Optional[dict[str, str]] = None
+
+    def label_for(self, health: 'Health') -> str:
+        """Return the display label for a health state, or the state name if no label set."""
+        if self.labels:
+            return self.labels.get(health.value, health.value)
+        return health.value
+
+    def to_dict(self) -> dict:
+        """Serialize to a plain dict (labels included if set)."""
+        d: dict = {
+            "intact": self.intact,
+            "ablated": self.ablated,
+            "higher_is_better": self.higher_is_better,
+            "active_min": self.active_min,
+        }
+        if self.labels:
+            d["labels"] = dict(self.labels)
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> 'Thresholds':
+        """Deserialize from a plain dict produced by to_dict()."""
+        return cls(
+            intact=d["intact"],
+            ablated=d["ablated"],
+            higher_is_better=d.get("higher_is_better", True),
+            active_min=d.get("active_min", 0.05),
+            labels=d.get("labels"),
+        )
 
     def __post_init__(self):
         if self.higher_is_better and self.ablated > self.intact:

{margin-0.9.1 → margin-0.9.3}/margin/loop.py

@@ -45,6 +45,7 @@ class StepResult:
     correction: Optional[Correction] = None
     escalation: Optional[Escalation] = None
     contract: Optional[ContractResult] = None
+    corrections: list = field(default_factory=list)  # all fired corrections (multi_rule)
 
     @property
     def acted(self) -> bool:
@@ -74,6 +75,8 @@ class StepResult:
             d["decision"] = self.decision.to_dict()
         if self.correction:
             d["correction"] = self.correction.to_dict()
+        if self.corrections:
+            d["corrections"] = [c.to_dict() for c in self.corrections]
         if self.escalation:
             d["escalation"] = self.escalation.to_dict()
         if self.contract:
@@ -140,6 +143,11 @@ def step(
     elif isinstance(decision.result, Escalation):
         escalation = decision.result
 
+    # Collect all corrections for multi_rule mode
+    all_corrections = []
+    if policy.multi_rule:
+        all_corrections = [r for r in decision.results if isinstance(r, Correction)]
+
     # 3. Evaluate contract
     contract_result = None
     if contract:
@@ -152,6 +160,7 @@ def step(
         correction=correction,
         escalation=escalation,
         contract=contract_result,
+        corrections=all_corrections,
     )
 
 

{margin-0.9.1 → margin-0.9.3}/margin/observation.py

@@ -60,6 +60,7 @@ class Observation:
     higher_is_better: bool = True
     provenance: list[str] = field(default_factory=list)
     measured_at: Optional[datetime] = None
+    health_label: Optional[str] = None
 
     @property
     def sigma(self) -> float:
@@ -91,10 +92,11 @@ class Observation:
 
     def to_atom(self) -> str:
         """Compact string: NAME:HEALTH(±σ)"""
+        display = self.health_label or self.health.value
         if self.health == Health.OOD:
-            return f"{self.name}:{self.health.value}"
+            return f"{self.name}:{display}"
         sign = "+" if self.sigma >= 0 else ""
-        return f"{self.name}:{self.health.value}({sign}{self.sigma:.2f}σ)"
+        return f"{self.name}:{display}({sign}{self.sigma:.2f}σ)"
 
     def to_dict(self) -> dict:
         d = {
@@ -107,6 +109,8 @@ class Observation:
             "higher_is_better": self.higher_is_better,
             "provenance": self.provenance,
         }
+        if self.health_label is not None:
+            d["health_label"] = self.health_label
         if self.measured_at is not None:
             d["measured_at"] = self.measured_at.isoformat()
         return d
@@ -125,6 +129,7 @@ class Observation:
             higher_is_better=d.get("higher_is_better", True),
             provenance=d.get("provenance", []),
             measured_at=measured_at,
+            health_label=d.get("health_label"),
         )
 
 
@@ -311,6 +316,10 @@ class Parser:
     def _thresholds_for(self, name: str) -> Thresholds:
         return self.component_thresholds.get(name, self.thresholds)
 
+    def label_for(self, component: str, health: Health) -> str:
+        """Return the display label for a component's health state."""
+        return self._thresholds_for(component).label_for(health)
+
     def parse(
         self,
         values: dict[str, float],
@@ -343,6 +352,7 @@ class Parser:
                 name=name, health=h, value=val, baseline=baseline,
                 confidence=conf, higher_is_better=ct.higher_is_better,
                 provenance=list(provenance),
+                health_label=ct.label_for(h) if ct.labels else None,
             ))
 
         corrections = []

{margin-0.9.1 → margin-0.9.3}/margin/persist.py

@@ -33,13 +33,14 @@ def save_monitor(monitor: Monitor, path: str) -> None:
         "anomaly_window": monitor.anomaly_window,
         "correlation_window": monitor.correlation_window,
         "anomaly_min_reference": _anomaly_min_ref,
+        "features": sorted(monitor.features),
         "drift": {},
         "anomaly": {},
         "correlation": {
             "components": monitor._correlation_tracker.components,
             "series": {c: list(d) for c, d in monitor._correlation_tracker._series.items()},
             "n_updates": monitor._correlation_tracker.n_updates,
-        },
+        } if monitor._correlation_tracker is not None else None,
     }
 
     for name, dt in monitor._drift_trackers.items():
@@ -71,12 +72,15 @@ def load_monitor(path: str, parser: Parser, **kwargs) -> Monitor:
     anomaly_window = data.get("anomaly_window", kwargs.pop("anomaly_window", None))
     correlation_window = data.get("correlation_window", kwargs.pop("correlation_window", None))
     anomaly_min_reference = data.get("anomaly_min_reference", kwargs.pop("anomaly_min_reference", 10))
+    features_data = data.get("features", None)
+    features = set(features_data) if features_data is not None else None
     monitor = Monitor(
         parser, window=window,
         drift_window=drift_window,
         anomaly_window=anomaly_window,
         correlation_window=correlation_window,
         anomaly_min_reference=anomaly_min_reference,
+        features=features,
         **kwargs,
     )
     monitor._step = data.get("step", 0)
@@ -101,12 +105,13 @@ def load_monitor(path: str, parser: Parser, **kwargs) -> Monitor:
                 tracker._values.append(v)
 
     # Restore correlation series
-    corr_data = data.get("correlation", {})
-    for c in monitor._correlation_tracker.components:
-        series = corr_data.get("series", {}).get(c, [])
-        for v in series:
-            monitor._correlation_tracker._series[c].append(v)
-    monitor._correlation_tracker._n_updates = corr_data.get("n_updates", 0)
+    corr_data = data.get("correlation")
+    if corr_data is not None and monitor._correlation_tracker is not None:
+        for c in monitor._correlation_tracker.components:
+            series = corr_data.get("series", {}).get(c, [])
+            for v in series:
+                monitor._correlation_tracker._series[c].append(v)
+        monitor._correlation_tracker._n_updates = corr_data.get("n_updates", 0)
 
     return monitor
 

{margin-0.9.1 → margin-0.9.3}/margin/policy/core.py

@@ -258,6 +258,7 @@ class Policy:
     rules: list[PolicyRule] = field(default_factory=list)
     default_constraint: Optional[Constraint] = None
     default_escalation: Optional[Escalation] = None
+    multi_rule: bool = False
 
     def evaluate(self, expr: Expression, ledger: Optional[Ledger] = None) -> list[Union[Correction, Escalation]]:
         matching = sorted([r for r in self.rules if r.matches(expr)],
@@ -305,7 +306,7 @@ class Policy:
         return results
 
     def to_dict(self) -> dict:
-        d: dict = {"name": self.name, "rules": [r.to_dict() for r in self.rules]}
+        d: dict = {"name": self.name, "rules": [r.to_dict() for r in self.rules], "multi_rule": self.multi_rule}
         if self.default_constraint:
             d["default_constraint"] = self.default_constraint.to_dict()
         if self.default_escalation:
@@ -324,6 +325,7 @@ class Policy:
             name=d["name"], rules=rules,
             default_constraint=Constraint.from_dict(d["default_constraint"]) if "default_constraint" in d else None,
             default_escalation=Escalation.from_dict(d["default_escalation"]) if "default_escalation" in d else None,
+            multi_rule=d.get("multi_rule", False),
         )
 
     def __repr__(self) -> str:

{margin-0.9.1 → margin-0.9.3}/margin/policy/trace.py

@@ -59,6 +59,7 @@ class DecisionTrace:
     winner: Optional[str] = None
     result: Optional[Union[Correction, Escalation]] = None
     causal_context: Optional[dict] = None  # from causal.explain_all() if available
+    results: list = field(default_factory=list)  # all fired corrections/escalations (multi_rule)
 
     @property
     def rules_considered(self) -> int:
@@ -111,6 +112,11 @@ class DecisionTrace:
             d["result_type"] = None
         if self.causal_context:
             d["causal_context"] = self.causal_context
+        if self.results:
+            d["results"] = [
+                r.to_dict() if hasattr(r, 'to_dict') else str(r)
+                for r in self.results
+            ]
         return d
 
     def __repr__(self) -> str:
@@ -132,12 +138,12 @@ def trace_evaluate(
     attached to the trace for auditability.
     """
     dt = DecisionTrace(expression=expr, causal_context=causal_context)
-    winner_result = None
-    winner_name = None
 
     # Evaluate all rules in priority order
     sorted_rules = sorted(policy.rules, key=lambda r: r.priority, reverse=True)
 
+    all_results = []
+
     for rule in sorted_rules:
         matched = rule.matches(expr)
         ev = RuleEvaluation(
@@ -156,26 +162,24 @@ def trace_evaluate(
                     ev.outcome = "escalation"
                     ev.reason = f"{result.level.value}: {result.reason}"
                 ev.result = result
-
-                if winner_result is None:
-                    winner_result = result
-                    winner_name = rule.name
+                all_results.append((rule.name, result))
             else:
                 ev.outcome = "suppressed"
                 ev.reason = "evaluate returned None"
 
         dt.evaluations.append(ev)
 
-    if winner_result is None and policy.default_escalation:
-        winner_result = Escalation(
+    if not all_results and policy.default_escalation:
+        default_esc = Escalation(
             policy.default_escalation.level,
             policy.default_escalation.reason,
             "default",
         )
-        winner_name = "default"
+        all_results.append(("default", default_esc))
 
-    dt.winner = winner_name
-    dt.result = winner_result
+    dt.results = [r for _, r in all_results]
+    dt.winner = all_results[0][0] if all_results else None
+    dt.result = all_results[0][1] if all_results else None
     return dt
 
 

{margin-0.9.1 → margin-0.9.3}/margin/streaming.py

@@ -364,6 +364,7 @@ class Monitor:
         window_config: Optional[WindowConfig] = None,
         min_correlation: float = 0.7,
         anomaly_min_reference: int = 10,
+        features: Optional[set] = None,
     ):
         self.parser = parser
         self.window = window
@@ -374,7 +375,10 @@ class Monitor:
         self.anomaly_window = cfg.anomaly or anomaly_window or window
         self.correlation_window = cfg.correlation or correlation_window or window
 
-        if anomaly_min_reference > self.anomaly_window:
+        # Resolve feature flags: None means all enabled (backward compatible)
+        self.features = frozenset(features) if features is not None else frozenset({"drift", "anomaly", "correlation"})
+
+        if "anomaly" in self.features and anomaly_min_reference > self.anomaly_window:
             warnings.warn(
                 f"Monitor: anomaly_min_reference={anomaly_min_reference} > "
                 f"anomaly_window={self.anomaly_window} — AnomalyTrackers will never "
@@ -386,22 +390,28 @@ class Monitor:
         self._expression: Optional[Expression] = None
         self._step = 0
 
-        # Create per-component trackers
+        # Create per-component trackers for enabled features only
         self._drift_trackers: dict[str, DriftTracker] = {}
         self._anomaly_trackers: dict[str, AnomalyTracker] = {}
 
-        for name in parser.baselines:
-            self._drift_trackers[name] = DriftTracker(name, window=self.drift_window)
-            self._anomaly_trackers[name] = AnomalyTracker(
-                name, window=self.anomaly_window, min_reference=anomaly_min_reference,
-            )
+        if "drift" in self.features:
+            for name in parser.baselines:
+                self._drift_trackers[name] = DriftTracker(name, window=self.drift_window)
 
-        # Correlation tracker across all components
-        self._correlation_tracker = CorrelationTracker(
-            list(parser.baselines.keys()),
-            window=self.correlation_window,
-            min_correlation=min_correlation,
-        )
+        if "anomaly" in self.features:
+            for name in parser.baselines:
+                self._anomaly_trackers[name] = AnomalyTracker(
+                    name, window=self.anomaly_window, min_reference=anomaly_min_reference,
+                )
+
+        if "correlation" in self.features:
+            self._correlation_tracker: Optional[CorrelationTracker] = CorrelationTracker(
+                list(parser.baselines.keys()),
+                window=self.correlation_window,
+                min_correlation=min_correlation,
+            )
+        else:
+            self._correlation_tracker = None
 
     def update(
         self,
@@ -440,7 +450,8 @@ class Monitor:
                 self._anomaly_trackers[name].update(obs.value)
 
         # Correlation
-        self._correlation_tracker.update(values)
+        if self._correlation_tracker is not None:
+            self._correlation_tracker.update(values)
 
         return self._expression
 
@@ -458,6 +469,8 @@ class Monitor:
 
     @property
     def correlations(self) -> Optional[CorrelationMatrix]:
+        if self._correlation_tracker is None:
+            return None
         return self._correlation_tracker.matrix
 
     @property
@@ -469,16 +482,18 @@ class Monitor:
         d: dict = {
             "step": self._step,
             "expression": self._expression.to_dict() if self._expression else None,
-            "drift": {},
-            "anomaly": {},
         }
-        for name, tracker in self._drift_trackers.items():
-            if tracker.classification:
-                d["drift"][name] = tracker.classification.to_dict()
-        for name, tracker in self._anomaly_trackers.items():
-            if tracker.classification:
-                d["anomaly"][name] = tracker.classification.to_dict()
-        if self._correlation_tracker.matrix:
+        if "drift" in self.features:
+            d["drift"] = {}
+            for name, tracker in self._drift_trackers.items():
+                if tracker.classification:
+                    d["drift"][name] = tracker.classification.to_dict()
+        if "anomaly" in self.features:
+            d["anomaly"] = {}
+            for name, tracker in self._anomaly_trackers.items():
+                if tracker.classification:
+                    d["anomaly"][name] = tracker.classification.to_dict()
+        if self._correlation_tracker is not None and self._correlation_tracker.matrix:
             d["correlations"] = self._correlation_tracker.matrix.to_dict()
         return d
 
@@ -506,7 +521,8 @@ class Monitor:
             t.reset()
         for t in self._anomaly_trackers.values():
             t.reset()
-        self._correlation_tracker.reset()
+        if self._correlation_tracker is not None:
+            self._correlation_tracker.reset()
 
     def __repr__(self) -> str:
         windows_uniform = (self.drift_window == self.anomaly_window == self.correlation_window)
@@ -514,4 +530,9 @@ class Monitor:
             w = f"window={self.drift_window}"
         else:
             w = f"drift={self.drift_window}, anomaly={self.anomaly_window}, corr={self.correlation_window}"
-        return f"Monitor(step={self._step}, {len(self._drift_trackers)} components, {w})"
+        all_features = frozenset({"drift", "anomaly", "correlation"})
+        if self.features == all_features:
+            feat = ""
+        else:
+            feat = f", features={{{', '.join(sorted(self.features))}}}"
+        return f"Monitor(step={self._step}, {len(self._drift_trackers)} components, {w}{feat})"

{margin-0.9.1 → margin-0.9.3/margin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.1
+Version: 0.9.3
 Summary: Typed health classification, uncertainty algebra, and correction auditing for any system that measures things and needs to explain what happened.
 Author: Cope Labs LLC
 License: MIT

{margin-0.9.1 → margin-0.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.1"
+version = "0.9.3"
 description = "Typed health classification, uncertainty algebra, and correction auditing for any system that measures things and needs to explain what happened."
 readme = "README.md"
 license = {text = "MIT"}

{margin-0.9.1 → margin-0.9.3}/tests/test_calibrate.py

@@ -97,3 +97,82 @@ class TestParserFromCalibration:
     def test_empty_raises(self):
         with pytest.raises(ValueError):
             parser_from_calibration({})
+
+
+class TestCalibrateUseStd:
+    def test_higher_is_better_thresholds(self):
+        # mean=100, std=10 → intact=85 (100-1.5*10), ablated=70 (100-3*10)
+        r = calibrate([90.0, 100.0, 110.0], use_std=True)
+        assert r.thresholds.intact == pytest.approx(85.0, abs=0.1)
+        assert r.thresholds.ablated == pytest.approx(70.0, abs=0.1)
+        assert r.thresholds.higher_is_better is True
+
+    def test_lower_is_better_thresholds(self):
+        # mean=0.01, std=0.001 → intact=0.0115 (0.01+1.5*0.001), ablated=0.013 (0.01+3*0.001)
+        r = calibrate([0.009, 0.010, 0.011], use_std=True, higher_is_better=False)
+        assert r.thresholds.higher_is_better is False
+        assert r.thresholds.intact == pytest.approx(0.0115, abs=0.0001)
+        assert r.thresholds.ablated == pytest.approx(0.013, abs=0.0001)
+
+    def test_custom_multipliers(self):
+        # mean=100, std=10 → intact=100-2*10=80, ablated=100-4*10=60
+        r = calibrate([90.0, 100.0, 110.0], use_std=True,
+                      intact_std_multiplier=2.0, ablated_std_multiplier=4.0)
+        assert r.thresholds.intact == pytest.approx(80.0, abs=0.1)
+        assert r.thresholds.ablated == pytest.approx(60.0, abs=0.1)
+
+    def test_zero_variance_raises(self):
+        with pytest.raises(ValueError, match="zero-variance"):
+            calibrate([100.0, 100.0, 100.0], use_std=True)
+
+    def test_threads_through_calibrate_many(self):
+        from margin.calibrate import calibrate_many
+        _, thresholds = calibrate_many(
+            {"rps": [90.0, 100.0, 110.0]},
+            use_std=True,
+        )
+        # Should not raise; thresholds set from std mode
+        assert thresholds["rps"].intact < 100.0
+
+    def test_threads_through_parser_from_calibration(self):
+        p = parser_from_calibration(
+            {"rps": [90.0, 100.0, 110.0]},
+            use_std=True,
+        )
+        expr = p.parse({"rps": 60.0})
+        assert expr.health_of("rps") in (Health.ABLATED, Health.DEGRADED)
+
+
+class TestNeedsRecalibrationMany:
+    from margin.calibrate import needs_recalibration_many as _nrm
+
+    def test_stable_data_no_recalibration(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20, "mem": [70.0] * 20}
+        recent = {"cpu": [50.5] * 10, "mem": [70.2] * 10}
+        flags = needs_recalibration_many(cal, recent)
+        assert flags["cpu"] is False
+        assert flags["mem"] is False
+
+    def test_mean_shift_triggers_recalibration(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20}
+        recent = {"cpu": [100.0] * 10}  # >20% shift
+        flags = needs_recalibration_many(cal, recent)
+        assert flags["cpu"] is True
+
+    def test_returns_per_component_dict(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20, "mem": [70.0] * 20, "err": [0.01] * 20}
+        recent = {"cpu": [50.0] * 10, "mem": [70.0] * 10, "err": [0.01] * 10}
+        flags = needs_recalibration_many(cal, recent)
+        assert set(flags.keys()) == {"cpu", "mem", "err"}
+        assert all(isinstance(v, bool) for v in flags.values())
+
+    def test_partial_subset_triggers(self):
+        from margin.calibrate import needs_recalibration_many
+        cal = {"cpu": [50.0] * 20, "mem": [70.0] * 20}
+        recent = {"cpu": [100.0] * 10, "mem": [70.1] * 10}
+        flags = needs_recalibration_many(cal, recent)
+        assert flags["cpu"] is True
+        assert flags["mem"] is False

{margin-0.9.1 → margin-0.9.3}/tests/test_health.py

@@ -97,3 +97,48 @@ class TestClassifyEdgeCases:
     def test_negative_inf_lower_is_better(self):
         t = Thresholds(intact=0.02, ablated=0.10, higher_is_better=False)
         assert classify(float('-inf'), Confidence.HIGH, thresholds=t) == Health.INTACT
+
+
+class TestThresholdsLabels:
+    def test_label_for_returns_custom(self):
+        t = Thresholds(intact=80.0, ablated=30.0, labels={"ABLATED": "CRITICAL", "INTACT": "OK"})
+        assert t.label_for(Health.ABLATED) == "CRITICAL"
+        assert t.label_for(Health.INTACT) == "OK"
+
+    def test_label_for_fallback_to_enum(self):
+        t = Thresholds(intact=80.0, ablated=30.0, labels={"ABLATED": "CRITICAL"})
+        assert t.label_for(Health.DEGRADED) == "DEGRADED"
+
+    def test_no_labels_returns_enum_name(self):
+        t = Thresholds(intact=80.0, ablated=30.0)
+        assert t.label_for(Health.INTACT) == "INTACT"
+
+    def test_to_dict_includes_labels(self):
+        t = Thresholds(intact=80.0, ablated=30.0, labels={"ABLATED": "CRITICAL"})
+        d = t.to_dict()
+        assert d["labels"] == {"ABLATED": "CRITICAL"}
+        assert d["intact"] == 80.0
+        assert d["ablated"] == 30.0
+        assert d["higher_is_better"] is True
+        assert d["active_min"] == pytest.approx(0.05)
+
+    def test_to_dict_omits_labels_when_none(self):
+        t = Thresholds(intact=80.0, ablated=30.0)
+        d = t.to_dict()
+        assert "labels" not in d
+
+    def test_from_dict_roundtrip(self):
+        t = Thresholds(intact=0.01, ablated=0.10, higher_is_better=False,
+                       active_min=0.1, labels={"INTACT": "GOOD", "DEGRADED": "WARN"})
+        t2 = Thresholds.from_dict(t.to_dict())
+        assert t2.intact == t.intact
+        assert t2.ablated == t.ablated
+        assert t2.higher_is_better == t.higher_is_better
+        assert t2.active_min == t.active_min
+        assert t2.labels == t.labels
+
+    def test_from_dict_no_labels(self):
+        t = Thresholds.from_dict({"intact": 80.0, "ablated": 30.0})
+        assert t.labels is None
+        assert t.higher_is_better is True
+        assert t.active_min == pytest.approx(0.05)

{margin-0.9.1 → margin-0.9.3}/tests/test_observation.py

@@ -210,3 +210,61 @@ class TestParserPolarity:
         e = p.parse({"throughput": 95.0, "err": 0.08}, correction_magnitude=1.0, alpha=0.5)
         assert e.corrections[0].target == "err"
         assert e.corrections[0].op == Op.RESTORE
+
+
+class TestHealthLabel:
+    def test_to_atom_uses_health_label(self):
+        obs = Observation(
+            name="cpu", health=Health.ABLATED, value=10.0, baseline=100.0,
+            confidence=Confidence.HIGH, health_label="CRITICAL",
+        )
+        atom = obs.to_atom()
+        assert "CRITICAL" in atom
+        assert "ABLATED" not in atom
+
+    def test_to_atom_fallback_when_no_label(self):
+        obs = Observation(
+            name="cpu", health=Health.DEGRADED, value=60.0, baseline=100.0,
+            confidence=Confidence.HIGH,
+        )
+        atom = obs.to_atom()
+        assert "DEGRADED" in atom
+
+    def test_parser_sets_health_label(self):
+        p = Parser(
+            baselines={"cpu": 100.0},
+            thresholds=Thresholds(
+                intact=80.0, ablated=30.0,
+                labels={"ABLATED": "CRITICAL", "DEGRADED": "WARNING", "INTACT": "OK"},
+            ),
+        )
+        expr = p.parse({"cpu": 10.0})
+        obs = expr.observations[0]
+        assert obs.health_label == "CRITICAL"
+        assert "CRITICAL" in obs.to_atom()
+
+    def test_parser_label_for(self):
+        p = Parser(
+            baselines={"cpu": 100.0},
+            thresholds=Thresholds(intact=80.0, ablated=30.0, labels={"INTACT": "OK"}),
+        )
+        assert p.label_for("cpu", Health.INTACT) == "OK"
+        assert p.label_for("cpu", Health.DEGRADED) == "DEGRADED"
+
+    def test_health_label_to_dict_roundtrip(self):
+        obs = Observation(
+            name="mem", health=Health.DEGRADED, value=60.0, baseline=100.0,
+            confidence=Confidence.HIGH, health_label="WARNING",
+        )
+        d = obs.to_dict()
+        assert d["health_label"] == "WARNING"
+        obs2 = Observation.from_dict(d)
+        assert obs2.health_label == "WARNING"
+
+    def test_health_label_none_not_in_dict(self):
+        obs = Observation(
+            name="mem", health=Health.INTACT, value=95.0, baseline=100.0,
+            confidence=Confidence.HIGH,
+        )
+        d = obs.to_dict()
+        assert "health_label" not in d

{margin-0.9.1 → margin-0.9.3}/tests/test_persist.py

@@ -214,3 +214,53 @@ class TestCLI:
         assert result.returncode == 0
         assert "cpu" in result.stdout
         assert "INTACT" in result.stdout or "DEGRADED" in result.stdout
+
+
+class TestFeaturesRoundtrip:
+    def test_partial_features_saved_and_restored(self):
+        p = _parser()
+        m = Monitor(p, features={"health", "drift"})
+        for i in range(10):
+            m.update({"cpu": 50.0 - i, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            save_monitor(m, f.name)
+            m2 = load_monitor(f.name, p)
+            Path(f.name).unlink()
+
+        assert m2.features == frozenset({"health", "drift"})
+        assert len(m2._drift_trackers) == 2
+        assert m2._correlation_tracker is None
+
+    def test_all_features_roundtrip(self):
+        p = _parser()
+        m = Monitor(p, features={"health", "drift", "anomaly", "correlation"})
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            save_monitor(m, f.name)
+            m2 = load_monitor(f.name, p)
+            Path(f.name).unlink()
+
+        assert "drift" in m2.features
+        assert "anomaly" in m2.features
+        assert "correlation" in m2.features
+
+    def test_anomaly_min_reference_roundtrip(self):
+        p = _parser()
+        m = Monitor(p, anomaly_min_reference=25)
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            save_monitor(m, f.name)
+            data = json.loads(Path(f.name).read_text())
+            m2 = load_monitor(f.name, p)
+            Path(f.name).unlink()
+
+        assert data["anomaly_min_reference"] == 25
+        assert m2._anomaly_trackers["cpu"]._min_reference == 25

{margin-0.9.1 → margin-0.9.3}/tests/test_policy_trace.py

@@ -136,3 +136,96 @@ class TestBacktestProposedBy:
         ledger = Ledger(records=[_rec(0, "x", Health.DEGRADED)])
         bt = policy.backtest(ledger)
         assert bt[0]["proposed_by"] == ""
+
+
+class TestMultiRule:
+    def _make_multi_policy(self):
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_health, any_degraded
+        return Policy(
+            name="multi",
+            multi_rule=True,
+            rules=[
+                PolicyRule("log", any_degraded(),
+                           Action(target="*", op=Op.NOOP, alpha=0.0), priority=5),
+                PolicyRule("restore", any_health(Health.DEGRADED),
+                           Action(target="*", op=Op.RESTORE, alpha=0.5), priority=10),
+            ],
+        )
+
+    def test_multi_rule_all_matching_rules_fire(self):
+        policy = self._make_multi_policy()
+        dt = trace_evaluate(policy, _expr(_obs("x", Health.DEGRADED)))
+        # Both rules match DEGRADED
+        assert len(dt.results) == 2
+
+    def test_multi_rule_winner_is_highest_priority(self):
+        policy = self._make_multi_policy()
+        dt = trace_evaluate(policy, _expr(_obs("x", Health.DEGRADED)))
+        assert dt.winner == "restore"
+        assert dt.result is not None
+
+    def test_trace_always_has_all_matched_results(self):
+        # trace_evaluate always populates dt.results for all matches;
+        # multi_rule only gates StepResult.corrections in step()
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_degraded
+        policy = Policy(
+            name="single",
+            multi_rule=False,
+            rules=[
+                PolicyRule("r1", any_degraded(), Action(target="*", op=Op.RESTORE, alpha=0.5), priority=10),
+                PolicyRule("r2", any_degraded(), Action(target="*", op=Op.NOOP), priority=5),
+            ],
+        )
+        dt = trace_evaluate(policy, _expr(_obs("x", Health.DEGRADED)))
+        # Both rules match — trace always records all; multi_rule only affects step()
+        assert len(dt.results) == 2
+        assert dt.winner == "r1"  # highest priority still wins
+
+    def test_multi_rule_to_dict_includes_multi_rule_flag(self):
+        policy = self._make_multi_policy()
+        d = policy.to_dict()
+        assert d["multi_rule"] is True
+
+    def test_multi_rule_default_is_false(self):
+        from margin.policy.core import Policy
+        policy = Policy(name="p", rules=[])
+        assert policy.multi_rule is False
+        assert policy.to_dict()["multi_rule"] is False
+
+
+class TestStepResultCorrections:
+    def test_step_corrections_populated_multi_rule(self):
+        from margin.loop import step
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_degraded
+
+        policy = Policy(
+            name="multi",
+            multi_rule=True,
+            rules=[
+                PolicyRule("r1", any_degraded(), Action(target="*", op=Op.RESTORE, alpha=0.5), priority=10),
+                PolicyRule("r2", any_degraded(), Action(target="*", op=Op.NOOP), priority=5),
+            ],
+        )
+        result = step(_expr(_obs("x", Health.DEGRADED)), policy)
+        assert len(result.corrections) >= 1
+
+    def test_step_corrections_empty_single_rule(self):
+        from margin.loop import step
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_degraded
+
+        policy = Policy(
+            name="single",
+            multi_rule=False,
+            rules=[PolicyRule("r", any_degraded(), Action(target="*", op=Op.RESTORE, alpha=0.5))],
+        )
+        result = step(_expr(_obs("x", Health.DEGRADED)), policy)
+        # multi_rule=False → corrections list is empty (only .correction populated)
+        assert result.corrections == []

{margin-0.9.1 → margin-0.9.3}/tests/test_streaming.py

@@ -284,3 +284,124 @@ class TestMonitor:
         m = Monitor(self._parser())
         assert "Monitor" in repr(m)
         assert "3 components" in repr(m)
+
+
+# -----------------------------------------------------------------------
+# Monitor — feature flags
+# -----------------------------------------------------------------------
+
+class TestMonitorFeatures:
+    def _parser(self):
+        return Parser(
+            baselines={"cpu": 50.0, "mem": 70.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        )
+
+    def test_default_features_all_enabled(self):
+        m = Monitor(self._parser())
+        assert "drift" in m.features
+        assert "anomaly" in m.features
+        assert "correlation" in m.features
+
+    def test_features_health_only_skips_trackers(self):
+        m = Monitor(self._parser(), features={"health"})
+        assert len(m._drift_trackers) == 0
+        assert len(m._anomaly_trackers) == 0
+        assert m._correlation_tracker is None
+
+    def test_features_health_drift_no_anomaly(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        assert len(m._drift_trackers) == 2
+        assert len(m._anomaly_trackers) == 0
+        assert m._correlation_tracker is None
+
+    def test_features_health_anomaly_no_drift(self):
+        m = Monitor(self._parser(), features={"health", "anomaly"})
+        assert len(m._drift_trackers) == 0
+        assert len(m._anomaly_trackers) == 2
+
+    def test_update_works_with_partial_features(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        expr = m.update({"cpu": 48.0, "mem": 65.0})
+        assert expr is not None
+        assert m.step == 1
+
+    def test_features_is_frozenset(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        assert isinstance(m.features, frozenset)
+
+    def test_status_omits_disabled_feature_keys(self):
+        m = Monitor(self._parser(), features={"health"})
+        for i in range(5):
+            m.update({"cpu": 50.0 - i, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        s = m.status()
+        # drift disabled → "drift" key absent
+        assert "drift" not in s
+        assert "anomaly" not in s
+
+    def test_repr_shows_features_when_partial(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        r = repr(m)
+        assert "features" in r
+
+    def test_repr_no_features_label_when_all_enabled(self):
+        m = Monitor(self._parser())
+        r = repr(m)
+        assert "features" not in r
+
+    def test_reset_works_with_partial_features(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        for i in range(5):
+            m.update({"cpu": 50.0 - i, "mem": 70.0})
+        m.reset()
+        assert m.step == 0
+
+
+# -----------------------------------------------------------------------
+# Monitor — reset_anomaly_reference
+# -----------------------------------------------------------------------
+
+class TestMonitorResetAnomalyReference:
+    def _parser(self):
+        return Parser(
+            baselines={"cpu": 50.0, "mem": 70.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        )
+
+    def test_reset_clears_all_reference_values(self):
+        m = Monitor(self._parser(), anomaly_min_reference=5)
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        assert m._anomaly_trackers["cpu"].n_values == 10
+        m.reset_anomaly_reference()
+        assert m._anomaly_trackers["cpu"].n_values == 0
+        assert m._anomaly_trackers["mem"].n_values == 0
+
+    def test_reset_specific_components(self):
+        m = Monitor(self._parser(), anomaly_min_reference=5)
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        m.reset_anomaly_reference(components=["cpu"])
+        assert m._anomaly_trackers["cpu"].n_values == 0
+        assert m._anomaly_trackers["mem"].n_values == 10
+
+    def test_reset_allows_fresh_reference(self):
+        m = Monitor(self._parser(), anomaly_min_reference=5)
+        # Build reference at baseline=50
+        for i in range(10):
+            m.update({"cpu": 50.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=i * 60))
+        m.reset_anomaly_reference()
+        # Feed new baseline at 100 — should warm up without contamination
+        for i in range(10):
+            m.update({"cpu": 100.0, "mem": 70.0},
+                     now=t0 + timedelta(seconds=(20 + i) * 60))
+        assert m._anomaly_trackers["cpu"].n_values == 10
+
+    def test_reset_noop_when_anomaly_disabled(self):
+        m = Monitor(self._parser(), features={"health", "drift"})
+        # Should not raise even though anomaly trackers don't exist
+        m.reset_anomaly_reference()