margin 0.9.5__tar.gz → 0.9.7__tar.gz

{margin-0.9.5/margin.egg-info → margin-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.5
+Version: 0.9.7
 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.5 → margin-0.9.7}/margin/calibrate.py

@@ -44,6 +44,13 @@ class CalibrationResult:
             "active_min": self.thresholds.active_min,
         }
 
+    def __repr__(self) -> str:
+        t = self.thresholds
+        polarity = "↑" if t.higher_is_better else "↓"
+        return (f"CalibrationResult(baseline={self.baseline:.4g}, "
+                f"intact={t.intact:.4g}, ablated={t.ablated:.4g}, "
+                f"std={self.std:.4g}, n={self.n_samples}, {polarity})")
+
 
 def calibrate(
     values: list[float],

{margin-0.9.5 → margin-0.9.7}/margin/config.py

@@ -19,8 +19,8 @@ from typing import Optional
 
 from .health import Thresholds
 from .observation import Parser, Op
-from .policy.core import Action, PolicyRule, Policy
-from .contract import Contract, HealthTarget, Health
+from .policy.core import Action, PolicyRule, Policy, Constraint, Escalation, EscalationLevel
+from .contract import Contract, HealthTarget, Health, contract_term_from_dict
 from .predicates import (
     any_health, all_health, any_degraded, any_correction,
     confidence_below, sigma_below, component_health,
@@ -125,6 +125,7 @@ def from_config(config: dict) -> dict:
             intact=spec.get("intact", default_intact),
             ablated=spec.get("ablated", default_ablated),
             higher_is_better=hib,
+            labels=spec.get("labels"),
         )
 
     # Use first component's thresholds as default (or the explicit default)
@@ -153,25 +154,61 @@ def from_config(config: dict) -> dict:
                 op=Op(action_spec.get("op", "RESTORE")),
                 alpha=action_spec.get("alpha", 0.5),
                 magnitude=action_spec.get("magnitude", 1.0),
+                alpha_from_sigma=action_spec.get("alpha_from_sigma", False),
+                magnitude_from_sigma=action_spec.get("magnitude_from_sigma", False),
             )
+            constraint = None
+            if "constraint" in spec:
+                cs = spec["constraint"]
+                constraint = Constraint(
+                    max_alpha=cs.get("max_alpha", 1.0),
+                    min_alpha=cs.get("min_alpha", 0.0),
+                    cooldown_steps=cs.get("cooldown_steps", 0),
+                    max_per_window=cs.get("max_per_window", 0),
+                    window_steps=cs.get("window_steps", 0),
+                )
+            escalation = None
+            if "escalation" in spec:
+                es = spec["escalation"]
+                escalation = Escalation(
+                    level=EscalationLevel(es.get("level", "LOG")),
+                    reason=es.get("reason", ""),
+                )
+            min_conf_str = spec.get("min_confidence")
+            min_confidence = Confidence(min_conf_str) if min_conf_str else Confidence.LOW
             rules.append(PolicyRule(
                 name=spec["name"],
                 predicate=predicate,
                 action=action,
                 priority=spec.get("priority", 0),
+                constraint=constraint,
+                escalation=escalation,
+                min_confidence=min_confidence,
             ))
-        result["policy"] = Policy(name=config.get("name", "config-policy"), rules=rules)
+        result["policy"] = Policy(
+            name=config.get("name", "config-policy"),
+            rules=rules,
+            multi_rule=config.get("multi_rule", False),
+        )
 
     # --- Contract ---
     contract_specs = config.get("contract", [])
     if contract_specs:
         terms = []
         for spec in contract_specs:
-            terms.append(HealthTarget(
-                name=spec["name"],
-                component=spec["component"],
-                target=Health(spec.get("health", "INTACT")),
-            ))
+            term_type = spec.get("type", "health_target")
+            if term_type == "health_target" and "type" not in spec:
+                # backward-compatible: old configs without explicit type field
+                terms.append(HealthTarget(
+                    name=spec["name"],
+                    component=spec["component"],
+                    target=Health(spec.get("health", "INTACT")),
+                ))
+            else:
+                # normalise: config may use "health" instead of "target"
+                if "health" in spec and "target" not in spec:
+                    spec = dict(spec, target=spec["health"])
+                terms.append(contract_term_from_dict(spec))
         result["contract"] = Contract(
             name=config.get("contract_name", "config-contract"),
             terms=terms,

{margin-0.9.5 → margin-0.9.7}/margin/contract.py

@@ -92,6 +92,9 @@ class HealthTarget(ContractTerm):
         return {"type": "health_target", "name": self.name, "component": self.component,
                 "target": self.target.value, "or_better": self.or_better}
 
+    def __repr__(self) -> str:
+        return f"HealthTarget({self.name!r}, {self.component}={self.target.value})"
+
 
 @dataclass
 class ReachHealth(ContractTerm):
@@ -138,6 +141,9 @@ class ReachHealth(ContractTerm):
         return {"type": "reach_health", "name": self.name, "component": self.component,
                 "target": self.target.value, "within_steps": self.within_steps}
 
+    def __repr__(self) -> str:
+        return f"ReachHealth({self.name!r}, {self.component}={self.target.value} within {self.within_steps})"
+
 
 @dataclass
 class SustainHealth(ContractTerm):
@@ -184,6 +190,9 @@ class SustainHealth(ContractTerm):
                 "target": self.target.value, "for_steps": self.for_steps,
                 "or_better": self.or_better}
 
+    def __repr__(self) -> str:
+        return f"SustainHealth({self.name!r}, {self.component}={self.target.value} for {self.for_steps})"
+
 
 @dataclass
 class RecoveryThreshold(ContractTerm):
@@ -212,6 +221,9 @@ class RecoveryThreshold(ContractTerm):
         return {"type": "recovery_threshold", "name": self.name,
                 "min_recovery": self.min_recovery, "over_steps": self.over_steps}
 
+    def __repr__(self) -> str:
+        return f"RecoveryThreshold({self.name!r}, min={self.min_recovery} over {self.over_steps})"
+
 
 @dataclass
 class NoHarmful(ContractTerm):
@@ -231,6 +243,9 @@ class NoHarmful(ContractTerm):
     def to_dict(self) -> dict:
         return {"type": "no_harmful", "name": self.name, "over_steps": self.over_steps}
 
+    def __repr__(self) -> str:
+        return f"NoHarmful({self.name!r}, over {self.over_steps})"
+
 
 _TERM_TYPES: dict = {
     "health_target": lambda d: HealthTarget(
@@ -337,5 +352,12 @@ class Contract:
     def to_dict(self) -> dict:
         return {"name": self.name, "terms": [t.to_dict() for t in self.terms]}
 
+    @classmethod
+    def from_dict(cls, d: dict) -> 'Contract':
+        return cls(
+            name=d.get("name", ""),
+            terms=[contract_term_from_dict(t) for t in d.get("terms", [])],
+        )
+
     def __repr__(self) -> str:
         return f"Contract({self.name!r}, {len(self.terms)} terms)"

{margin-0.9.5 → margin-0.9.7}/margin/ledger.py

@@ -211,11 +211,11 @@ class Ledger:
             "n_harmful": len(self.harmful()),
         }
 
+    def to_dict(self) -> dict:
+        return {"label": self.label, "records": [r.to_dict() for r in self.records]}
+
     def to_json(self, indent: int = 2) -> str:
-        return json.dumps({
-            "label": self.label,
-            "records": [r.to_dict() for r in self.records],
-        }, indent=indent)
+        return json.dumps(self.to_dict(), indent=indent)
 
     @classmethod
     def from_dict(cls, d: dict) -> 'Ledger':

{margin-0.9.5 → margin-0.9.7}/margin/loop.py

@@ -250,6 +250,8 @@ class FullStepResult:
             d["drift"] = {k: v.to_dict() for k, v in self.drift.items()}
         if self.anomaly:
             d["anomaly"] = {k: v.to_dict() for k, v in self.anomaly.items()}
+        if self.correlations is not None and self.correlations.to_dict():
+            d["correlations"] = self.correlations.to_dict()
         if self.intent:
             d["intent"] = self.intent.to_dict()
         return d
@@ -281,6 +283,9 @@ def full_step(
     contract: Optional[Contract] = None,
     intent: Optional[object] = None,
     now=None,
+    confidences=None,
+    provenance=None,
+    label: str = "",
 ) -> FullStepResult:
     """
     Run ALL layers in one call:
@@ -289,14 +294,17 @@ def full_step(
       3. Intent.evaluate() → goal feasibility
 
     Args:
-        monitor:   streaming Monitor
-        values:    raw measurements {component: value}
-        policy:    decision policy
-        ledger:    correction ledger (optional)
-        graph:     causal graph (optional)
-        contract:  success contract (optional)
-        intent:    Intent goal (optional)
-        now:       current timestamp (optional)
+        monitor:      streaming Monitor
+        values:       raw measurements {component: value}
+        policy:       decision policy
+        ledger:       correction ledger (optional)
+        graph:        causal graph (optional)
+        contract:     success contract (optional)
+        intent:       Intent goal (optional)
+        now:          current timestamp (optional)
+        confidences:  per-component Confidence overrides (optional)
+        provenance:   provenance tags for all observations (optional)
+        label:        expression label for this step (optional)
 
     Returns FullStepResult with all stages evaluated.
     """
@@ -305,7 +313,8 @@ def full_step(
     now = now or datetime.now()
 
     # Layer 1-4: health + drift + anomaly + correlation
-    expr = monitor.update(values, now=now)
+    expr = monitor.update(values, now=now, label=label,
+                          confidences=confidences, provenance=provenance)
 
     # Layer 5-7: explain + decide + contract
     step_result = step(expr, policy, ledger, graph, contract)

{margin-0.9.5 → margin-0.9.7}/margin/observation.py

@@ -333,16 +333,26 @@ class Parser:
         """
         Parse a set of component measurements into a typed Expression.
 
-        values:     {component_name: measurement}
+        values:               {component_name: measurement}
         correction_magnitude: size of the correction being applied
-        alpha:      mixing coefficient for the correction
-        confidences: per-component confidence (defaults to MODERATE)
+        alpha:                mixing coefficient for the correction
+        confidences:          per-component Confidence overrides (defaults to MODERATE)
+        label:                tag for this expression (e.g. step identifier)
+        step:                 step index (set automatically by Monitor)
+        provenance:           provenance tags attached to all observations
         """
         confidences = confidences or {}
         provenance = provenance or []
 
         observations = []
         for name, val in values.items():
+            if name not in self.baselines:
+                warnings.warn(
+                    f"Parser.parse: component {name!r} has no baseline — "
+                    "using the observed value as baseline (sigma=0). "
+                    "Add it to Parser.baselines or check for a typo.",
+                    stacklevel=2,
+                )
             baseline = self.baselines.get(name, val)
             conf = confidences.get(name, Confidence.MODERATE)
             ct = self._thresholds_for(name)

{margin-0.9.5 → margin-0.9.7}/margin/policy/core.py

@@ -7,6 +7,7 @@ constrained Correction or Escalation.
 
 from __future__ import annotations
 
+import warnings
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Callable, Optional, Union
@@ -97,6 +98,13 @@ class Action:
                 if o.name == target_name:
                     target_obs = o
                     break
+            if target_obs is None:
+                warnings.warn(
+                    f"Action.resolve: target {self.target!r} not found in expression "
+                    f"({[o.name for o in expr.observations]}). "
+                    "Correction will reference a nonexistent component.",
+                    stacklevel=3,
+                )
 
         alpha = self.alpha
         if self.alpha_from_sigma and target_obs:
@@ -131,6 +139,9 @@ class Action:
             magnitude_from_sigma=d.get("magnitude_from_sigma", False),
         )
 
+    def __repr__(self) -> str:
+        return f"Action(target={self.target!r}, op={self.op.value}, alpha={self.alpha})"
+
 
 # -----------------------------------------------------------------------
 # Constraint
@@ -180,6 +191,18 @@ class Constraint:
     def from_dict(cls, d: dict) -> Constraint:
         return cls(**{k: d[k] for k in ("max_alpha", "min_alpha", "cooldown_steps", "max_per_window", "window_steps") if k in d})
 
+    def __repr__(self) -> str:
+        parts = []
+        if self.min_alpha > 0.0:
+            parts.append(f"min_alpha={self.min_alpha}")
+        if self.max_alpha < 1.0:
+            parts.append(f"max_alpha={self.max_alpha}")
+        if self.cooldown_steps > 0:
+            parts.append(f"cooldown={self.cooldown_steps}")
+        if self.max_per_window > 0:
+            parts.append(f"max_per_window={self.max_per_window}")
+        return f"Constraint({', '.join(parts)})" if parts else "Constraint()"
+
 
 # -----------------------------------------------------------------------
 # PolicyRule

{margin-0.9.5 → margin-0.9.7}/margin/streaming.py

@@ -54,6 +54,12 @@ class WindowConfig:
             correlation=d.get("correlation"),
         )
 
+    def __repr__(self) -> str:
+        parts = [f"{k}={v}" for k, v in
+                 [("drift", self.drift), ("anomaly", self.anomaly), ("correlation", self.correlation)]
+                 if v is not None]
+        return f"WindowConfig({', '.join(parts)})" if parts else "WindowConfig()"
+
 from .confidence import Confidence
 from .health import Health, Thresholds, classify
 from .observation import Observation, Expression
@@ -438,6 +444,8 @@ class Monitor:
         values: dict[str, float],
         label: str = "",
         now: Optional[datetime] = None,
+        confidences=None,
+        provenance=None,
     ) -> Expression:
         """
         Process new measurements: classify health, update drift, check anomalies.
@@ -447,7 +455,10 @@ class Monitor:
         now = now or datetime.now()
 
         # Health classification via Parser
-        self._expression = self.parser.parse(values, label=label, step=self._step)
+        self._expression = self.parser.parse(
+            values, label=label, step=self._step,
+            confidences=confidences, provenance=provenance,
+        )
         self._step += 1
 
         # Update per-component trackers

{margin-0.9.5 → margin-0.9.7/margin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: margin
-Version: 0.9.5
+Version: 0.9.7
 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.5 → margin-0.9.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "margin"
-version = "0.9.5"
+version = "0.9.7"
 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.5 → margin-0.9.7}/tests/test_config.py

@@ -181,3 +181,122 @@ class TestLoadConfig:
         assert "policy" in result
         assert "contract" in result
         Path(f.name).unlink()
+
+
+class TestConfigConstraintEscalation:
+    def test_constraint_from_config(self):
+        from margin import from_config
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{
+                "name": "throttle",
+                "when": "any_degraded",
+                "action": {"op": "RESTORE", "alpha": 0.5},
+                "constraint": {"min_alpha": 0.1, "cooldown_steps": 3},
+            }],
+        }
+        result = from_config(cfg)
+        rule = result["policy"].rules[0]
+        assert rule.constraint is not None
+        assert rule.constraint.min_alpha == 0.1
+        assert rule.constraint.cooldown_steps == 3
+
+    def test_escalation_from_config(self):
+        from margin import from_config
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{
+                "name": "alert",
+                "when": "any_ablated",
+                "action": {"op": "NOOP"},
+                "escalation": {"level": "ALERT", "reason": "cpu failed"},
+            }],
+        }
+        result = from_config(cfg)
+        rule = result["policy"].rules[0]
+        assert rule.escalation is not None
+        assert rule.escalation.reason == "cpu failed"
+
+    def test_contract_reach_health_from_config(self):
+        from margin import from_config
+        from margin.contract import ReachHealth
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "contract": [{
+                "type": "reach_health",
+                "name": "recovery",
+                "component": "cpu",
+                "target": "INTACT",
+                "within_steps": 10,
+            }],
+        }
+        result = from_config(cfg)
+        term = result["contract"].terms[0]
+        assert isinstance(term, ReachHealth)
+        assert term.within_steps == 10
+
+    def test_contract_backward_compat_no_type(self):
+        from margin import from_config
+        from margin.contract import HealthTarget
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "contract": [{"name": "ok", "component": "cpu", "health": "INTACT"}],
+        }
+        result = from_config(cfg)
+        assert isinstance(result["contract"].terms[0], HealthTarget)
+
+
+class TestConfigNewFields:
+    def test_alpha_from_sigma_in_config(self):
+        from margin import from_config
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{
+                "name": "dynamic",
+                "when": "any_degraded",
+                "action": {"op": "RESTORE", "alpha_from_sigma": True},
+            }],
+        }
+        result = from_config(cfg)
+        assert result["policy"].rules[0].action.alpha_from_sigma is True
+
+    def test_min_confidence_in_config(self):
+        from margin import from_config
+        from margin.confidence import Confidence
+        cfg = {
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{
+                "name": "high-conf-only",
+                "when": "any_degraded",
+                "action": {"op": "RESTORE", "alpha": 0.5},
+                "min_confidence": "high",
+            }],
+        }
+        result = from_config(cfg)
+        assert result["policy"].rules[0].min_confidence == Confidence.HIGH
+
+    def test_multi_rule_in_config(self):
+        from margin import from_config
+        cfg = {
+            "name": "my-policy",
+            "multi_rule": True,
+            "components": {"cpu": {"baseline": 50.0, "intact": 40.0, "ablated": 10.0}},
+            "policy": [{"name": "r", "when": "any_degraded", "action": {"op": "RESTORE"}}],
+        }
+        result = from_config(cfg)
+        assert result["policy"].multi_rule is True
+
+    def test_labels_in_config(self):
+        from margin import from_config
+        cfg = {
+            "components": {
+                "cpu": {
+                    "baseline": 50.0, "intact": 40.0, "ablated": 10.0,
+                    "labels": {"ABLATED": "CRITICAL", "INTACT": "OK"},
+                }
+            },
+        }
+        result = from_config(cfg)
+        from margin.health import Health
+        assert result["parser"].label_for("cpu", Health.ABLATED) == "CRITICAL"
+        assert result["parser"].label_for("cpu", Health.INTACT) == "OK"

{margin-0.9.5 → margin-0.9.7}/tests/test_contract.py

@@ -272,3 +272,24 @@ class TestContractTermFromDict:
         from margin import contract_term_from_dict
         with pytest.raises(ValueError, match="Unknown"):
             contract_term_from_dict({"type": "nonexistent", "name": "x"})
+
+
+class TestContractFromDict:
+    def test_roundtrip(self):
+        from margin import Contract, SustainHealth, HealthTarget
+        c = Contract(name="my-contract", terms=[
+            HealthTarget(name="h", component="cpu", target=Health.INTACT),
+            SustainHealth(name="s", component="cpu", target=Health.INTACT, for_steps=5),
+        ])
+        c2 = Contract.from_dict(c.to_dict())
+        assert c2.name == "my-contract"
+        assert len(c2.terms) == 2
+        assert isinstance(c2.terms[0], HealthTarget)
+        assert isinstance(c2.terms[1], SustainHealth)
+
+    def test_empty_contract_roundtrip(self):
+        from margin import Contract
+        c = Contract(name="empty")
+        c2 = Contract.from_dict(c.to_dict())
+        assert c2.name == "empty"
+        assert c2.terms == []

{margin-0.9.5 → margin-0.9.7}/tests/test_ledger.py

@@ -197,3 +197,27 @@ class TestLedgerRoundtrip:
         assert lr.records[0].op == Op.RESTORE
         assert lr.records[1].after is None
         assert lr.render() == ledger.render()
+
+
+class TestLedgerToDict:
+    def test_to_dict_roundtrip(self):
+        from margin.ledger import Ledger, Record
+        from margin.observation import Observation, Op
+        from margin.health import Health
+        from margin.confidence import Confidence
+
+        obs = Observation("cpu", Health.DEGRADED, 30.0, 50.0, Confidence.HIGH)
+        rec = Record(step=0, tag="s0", before=obs, fired=False, op=Op.NOOP, alpha=0.0)
+        ledger = Ledger(label="test", records=[rec])
+        d = ledger.to_dict()
+        assert d["label"] == "test"
+        assert len(d["records"]) == 1
+        ledger2 = Ledger.from_dict(d)
+        assert ledger2.label == "test"
+        assert len(ledger2.records) == 1
+
+    def test_to_json_uses_to_dict(self):
+        import json
+        from margin.ledger import Ledger
+        ledger = Ledger(label="x")
+        assert json.loads(ledger.to_json())["label"] == "x"

{margin-0.9.5 → margin-0.9.7}/tests/test_loop.py

@@ -184,3 +184,40 @@ class TestRun:
     def test_repr(self):
         result = step(_expr(_obs("x", Health.DEGRADED)), self._make_policy())
         assert "CORRECT" in repr(result)
+
+
+class TestFullStepThreading:
+    def _monitor(self):
+        from margin import Monitor, Parser, Thresholds
+        return Monitor(Parser(
+            baselines={"cpu": 50.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        ))
+
+    def _policy(self):
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op
+        from margin.predicates import any_degraded
+        return Policy("p", [PolicyRule("r", any_degraded(), Action("*", Op.RESTORE, 0.5))])
+
+    def test_full_step_confidences_threaded(self):
+        from margin import full_step
+        from margin.confidence import Confidence
+        m = self._monitor()
+        result = full_step(m, {"cpu": 20.0}, self._policy(),
+                           confidences={"cpu": Confidence.HIGH})
+        obs = result.expression.observations[0]
+        assert obs.confidence == Confidence.HIGH
+
+    def test_full_step_label_threaded(self):
+        from margin import full_step
+        m = self._monitor()
+        result = full_step(m, {"cpu": 20.0}, self._policy(), label="step-A")
+        assert result.expression.label == "step-A"
+
+    def test_full_step_provenance_threaded(self):
+        from margin import full_step
+        m = self._monitor()
+        result = full_step(m, {"cpu": 20.0}, self._policy(), provenance=["source-X"])
+        obs = result.expression.observations[0]
+        assert "source-X" in obs.provenance

{margin-0.9.5 → margin-0.9.7}/tests/test_observation.py

@@ -268,3 +268,41 @@ class TestHealthLabel:
         )
         d = obs.to_dict()
         assert "health_label" not in d
+
+
+class TestParserUnknownComponent:
+    def test_warns_on_unknown_component(self):
+        import warnings
+        p = Parser(
+            baselines={"cpu": 50.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        )
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            p.parse({"cpuu": 48.0})  # typo
+        assert len(w) == 1
+        assert "cpuu" in str(w[0].message)
+        assert "no baseline" in str(w[0].message)
+
+    def test_no_warning_for_known_component(self):
+        import warnings
+        p = Parser(
+            baselines={"cpu": 50.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        )
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            p.parse({"cpu": 48.0})
+        assert len(w) == 0
+
+    def test_unknown_component_gets_sigma_zero(self):
+        p = Parser(
+            baselines={"cpu": 50.0},
+            thresholds=Thresholds(intact=40.0, ablated=10.0),
+        )
+        import warnings
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            expr = p.parse({"unknown": 100.0})
+        obs = expr.observations[0]
+        assert obs.sigma == 0.0

{margin-0.9.5 → margin-0.9.7}/tests/test_policy.py

@@ -379,3 +379,36 @@ class TestSerialization:
         d = {"name": "test", "rules": [{"name": "x", "action": {"op": "RESTORE"}}]}
         with pytest.raises(ValueError, match="No predicate"):
             Policy.from_dict(d, {})
+
+
+class TestActionResolveUnknownTarget:
+    def test_warns_when_named_target_not_in_expression(self):
+        import warnings
+        from margin.policy.core import Policy, PolicyRule, Action
+        from margin.observation import Op, Parser, Expression
+        from margin.health import Thresholds
+        from margin.predicates import any_degraded
+
+        p = Parser(baselines={"cpu": 50.0}, thresholds=Thresholds(intact=40.0, ablated=10.0))
+        expr = p.parse({"cpu": 20.0})
+
+        action = Action(target="nonexistent", op=Op.RESTORE, alpha=0.5)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            action.resolve(expr)
+        assert any("nonexistent" in str(x.message) for x in w)
+
+    def test_no_warning_when_target_exists(self):
+        import warnings
+        from margin.policy.core import Action
+        from margin.observation import Op, Parser
+        from margin.health import Thresholds
+
+        p = Parser(baselines={"cpu": 50.0}, thresholds=Thresholds(intact=40.0, ablated=10.0))
+        expr = p.parse({"cpu": 20.0})
+
+        action = Action(target="cpu", op=Op.RESTORE, alpha=0.5)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            action.resolve(expr)
+        assert len(w) == 0