arbiter-engine 0.1.0__py3-none-any.whl

arbiter_engine/envelope.py

@@ -0,0 +1,270 @@
+"""The three-part response envelope.
+
+Every other agent tool in the ecosystem returns findings and stops. This one
+returns what it checked, what it could not see, and what it needs to know
+next. That sentence is the whole differentiator, and this module is it made
+mechanical rather than aspirational.
+
+Three legs, each with a distinct source:
+
+``checked``
+    How many (axiom, entity, indicator) evaluations the pass attempted, and
+    over how many entities. Comes from ``DetectionResult.evaluations_attempted``
+which had to be added — findings and declines were countable,
+    but their sum is *not* the total, because an evaluation that ran and found
+    nothing appears in neither.
+
+``not_checked``
+    What was declined and why, from the ``NotEvaluated`` records. Empty
+    is a real answer: it means every declared axiom was actually evaluated.
+
+``questions``
+    What the model is missing, from the DISCOVER-mode gap surface. Optional —
+    a caller with no topology supplies none, and the leg is then empty rather
+    than absent, because "no questions" and "questions not gathered" are
+    different and the ``meta.source`` field says which.
+
+**Envelope vocabulary is inherited, not invented.** ``source`` takes the same
+three values the established pattern established across ~50 endpoint modules —
+``live`` / ``warming_up`` / ``unavailable`` — with ``reason`` populated
+whenever it is not ``live``. Diverging here would be the vocabulary-drift
+An internal ruling decided against, in the newest public surface.
+
+**What this module does NOT do**: it does not decide whether a finding is
+important, rank findings, or summarise them in prose. It reports what the
+engine did.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Iterable, List, Optional, Sequence
+
+from .interfaces import DetectionResult, Problem
+from .types import NotEvaluated
+
+#: the established pattern envelope vocabulary, reused verbatim.
+SOURCE_LIVE = "live"
+SOURCE_WARMING_UP = "warming_up"
+SOURCE_UNAVAILABLE = "unavailable"
+
+
+@dataclass(frozen=True)
+class CheckedSummary:
+    """The denominator. ``invariants`` counts evaluations **attempted**, which
+    is the only figure that makes ``not_checked`` interpretable — 8 declined
+    out of 47 attempted is a different statement from 8 out of 9.
+
+    that sentence was true of one of the five construction sites.
+    The others reported, under the same name: the count of *declared* axioms
+    (``model_describe``), the number of traversal *steps* (``traverse``), and
+    the number of *matched findings* from a lookup (``attest``). So a
+    traversal that evaluated nothing answered "checked 3 invariants", and
+    ``model_describe`` answered with declarations — the exact
+    declared-versus-evaluated conflation raised to P1, in the one
+    field whose entire job is to be an honest denominator.
+
+    ``invariants`` now means evaluations attempted, everywhere, and nothing
+    else. Work that is not an evaluation reports itself in its own field:
+    ``steps`` for traversal, ``declared_invariants`` for what a model
+    declares. Both are omitted from the payload when zero, matching the
+    existing convention that an absent number is not invited to be read as a
+    measured zero.
+    """
+
+    invariants: int = 0
+    entities: int = 0
+    steps: int = 0
+    declared_invariants: int = 0
+
+    def to_dict(self) -> Dict[str, int]:
+        out = {"invariants": self.invariants, "entities": self.entities}
+        if self.steps:
+            out["steps"] = self.steps
+        if self.declared_invariants:
+            out["declared_invariants"] = self.declared_invariants
+        return out
+
+
+@dataclass(frozen=True)
+class Envelope:
+    """A tool response: what was checked, what was not, what is unknown."""
+
+    checked: CheckedSummary
+    findings: List[Problem] = field(default_factory=list)
+    not_checked: List[NotEvaluated] = field(default_factory=list)
+    questions: List[Dict[str, Any]] = field(default_factory=list)
+    source: str = SOURCE_LIVE
+    reason: Optional[str] = None
+
+    @property
+    def is_fully_evaluated(self) -> bool:
+        """True when nothing was declined. Deliberately not called
+        ``is_healthy`` — an envelope with no findings and eight declines is
+        not health, it is silence, and the two must not share a name."""
+        return not self.not_checked
+
+    def to_dict(self) -> Dict[str, Any]:
+        meta: Dict[str, Any] = {"source": self.source}
+        if self.reason is not None:
+            meta["reason"] = self.reason
+        return {
+            "checked": self.checked.to_dict(),
+            "findings": [_problem_to_dict(p) for p in self.findings],
+            "not_checked": [_not_evaluated_to_dict(n) for n in self.not_checked],
+            "questions": list(self.questions),
+            "meta": meta,
+        }
+
+
+def _problem_to_dict(problem: Problem) -> Dict[str, Any]:
+    axiom = getattr(problem, "axiom", None)
+    severity = getattr(problem, "severity", None)
+    return {
+        "entity_id": getattr(problem, "entity_id", ""),
+        "problem_type": getattr(problem, "problem_type", ""),
+        "axiom": getattr(axiom, "value", None) if axiom is not None else None,
+        "severity": getattr(severity, "value", None) if severity is not None else None,
+        "reason": getattr(problem, "reason", ""),
+    }
+
+
+def _not_evaluated_to_dict(record: NotEvaluated) -> Dict[str, Any]:
+    out: Dict[str, Any] = {
+        "entity_id": record.entity_id,
+        "entity_type": record.entity_type,
+        "indicator": record.indicator,
+        "axiom": record.axiom.value,
+        "reason": record.reason.value,
+    }
+    if record.detail:
+        out["detail"] = record.detail
+    # Only present for sample-floor declines; omitted rather than null so a
+    # reader is not invited to interpret a missing count as zero.
+    if record.observations_count is not None:
+        out["observations"] = record.observations_count
+    if record.required_count is not None:
+        out["required"] = record.required_count
+    # `observations` is a count INSIDE the window and `required` is
+    # a global floor. Emitting the pair without the window invites "collect
+    # more data", which is false whenever the rate cannot span the floor. The
+    # window and the measured interval make the ratio interpretable; the
+    # `remedy` line states the conclusion, because an agent reading this will
+    # act on it and should not have to do the arithmetic.
+    if record.window_seconds is not None:
+        out["window_seconds"] = record.window_seconds
+    if record.total_observations is not None:
+        out["total_observations"] = record.total_observations
+    if record.sampling_interval_seconds is not None:
+        out["sampling_interval_seconds"] = record.sampling_interval_seconds
+    if record.floor_unreachable_at_this_rate:
+        out["floor_unreachable_at_this_rate"] = True
+        out["remedy"] = (
+            f"sample more often than every "
+            f"{record.sampling_interval_seconds:.0f}s, or widen the window: "
+            f"{record.required_count} samples cannot fit in "
+            f"{record.window_seconds:.0f}s at the observed rate. Collecting "
+            f"for longer will not help."
+        )
+    return out
+
+
+def _question_to_dict(question: Any) -> Dict[str, Any]:
+    """Normalise a DISCOVER-mode question.
+
+    Accepts the engine's own ``TopologyQuestion`` and plain dicts, because the
+    gap surface is optional and a caller may supply its own.
+
+     corrected the field names here. The first version read
+    ``question`` and ``gap_type`` off the object; ``TopologyQuestion`` actually
+    carries ``question_text`` and a nested ``gap`` whose ``gap_type`` is the
+    enum. Both lookups fell through to ``getattr`` defaults, so a real
+    question serialised as its dataclass repr — a bug that could only surface
+    on wiring the thing to an actual traversal, which is what did.
+    """
+    if isinstance(question, dict):
+        return dict(question)
+
+    text = getattr(question, "question_text", None)
+    if text is None:
+        text = getattr(question, "question", None)
+    gap = getattr(question, "gap", None)
+    gap_type = getattr(gap, "gap_type", None) if gap is not None else None
+    location = getattr(gap, "location", None) if gap is not None else None
+
+    out: Dict[str, Any] = {
+        "question": text if text is not None else str(question),
+        "gap_type": getattr(gap_type, "value", str(gap_type)) if gap_type else None,
+        "location": location,
+    }
+    priority = getattr(question, "priority", None)
+    if priority is not None:
+        out["priority"] = priority
+    context = getattr(question, "context_path", None)
+    if context:
+        out["context_path"] = list(context)
+    return out
+
+
+def build_envelope(
+    result: DetectionResult,
+    questions: Optional[Sequence[Any]] = None,
+    source: str = SOURCE_LIVE,
+    reason: Optional[str] = None,
+) -> Envelope:
+    """Assemble an envelope from a detection pass.
+
+    ``findings`` merges ``problems`` and ``warnings`` deliberately. The
+    reasoner splits them by severity, which is a presentation choice; a caller
+    asking what was found wants both, and dropping warnings is how
+    BOUNDEDNESS's warning-threshold breach goes missing from a response that
+    claims to report findings.
+
+    ``questions`` is a sequence rather than derived here, because gathering
+    them requires a topology this module deliberately does not depend on.
+    """
+    ordered = sorted(
+        list(questions or []),
+        key=lambda q: getattr(q, "priority", 0.0) or 0.0,
+        reverse=True,
+    )
+    return Envelope(
+        checked=CheckedSummary(
+            invariants=getattr(result, "evaluations_attempted", 0),
+            entities=result.entities_checked,
+        ),
+        findings=list(result.problems) + list(result.warnings),
+        not_checked=list(result.not_evaluated),
+        questions=[_question_to_dict(q) for q in ordered],
+        source=source,
+        reason=reason,
+    )
+
+
+def unavailable_envelope(reason: str) -> Envelope:
+    """The established pattern's bootstrap-aware fallback: a tool whose substrate is not
+    up answers with an envelope naming the reason, never an error and never a
+    misleading empty success."""
+    return Envelope(
+        checked=CheckedSummary(),
+        source=SOURCE_UNAVAILABLE,
+        reason=reason,
+    )
+
+
+def summarise(envelope: Envelope) -> str:
+    """One-line human form, the shape the CD body sketched.
+
+    Used in tool descriptions and the demo transcript; the machine
+    contract is ``to_dict``.
+    """
+    parts = [
+        f"checked {envelope.checked.invariants} invariants "
+        f"across {envelope.checked.entities} entities",
+        f"findings {len(envelope.findings)}",
+        f"not_checked {len(envelope.not_checked)}",
+        f"questions {len(envelope.questions)}",
+    ]
+    if envelope.source != SOURCE_LIVE:
+        parts.append(f"source {envelope.source} ({envelope.reason})")
+    return "; ".join(parts)

arbiter_engine/examples/water_tank.yaml

@@ -0,0 +1,112 @@
+# A worked example: a two-tank water system.
+#
+# Deliberately synthetic. It is here to teach the schema and to give the engine
+# something to run against out of the box -- it is NOT one of the curated
+# domain models, which are not published. Every one of the eight axioms is
+# declared at least once below, so this file doubles as the schema reference.
+
+domain:
+  id: water-tank
+  name: Two-Tank Water System
+  description: >
+    A supply tank feeding a header tank through a pump, with a controller
+    holding the header level at setpoint. Small enough to read in one sitting.
+
+  entity_types:
+    - Tank
+    - Pump
+    - Controller
+
+  relationship_types:
+    - feeds
+    - controls
+
+  indicators:
+    Tank:
+      # BOUNDEDNESS -- an upper bound. Thresholds are upper bounds ONLY; for a
+      # lower-is-worse quantity use HOMEOSTASIS against a baseline instead.
+      - name: level_pct
+        type: NUMERIC
+        axioms: [BOUNDEDNESS, HOMEOSTASIS]
+        warning: 85
+        critical: 95
+        window: 1h
+
+      # CONSERVATION -- what flows in should leave or accumulate. The nested
+      # block is what makes this configurable from YAML at all.
+      - name: inflow_lps
+        type: NUMERIC
+        axioms: [CONSERVATION]
+        window: 15m
+        conservation:
+          output_properties: [outflow_lps]
+          tolerance: 0.05
+
+      - name: outflow_lps
+        type: NUMERIC
+        axioms: [] # observation-only: recorded, never checked per cycle
+
+      # CONSISTENCY -- two independent readings that should agree.
+      # `role: percentage` selects the 0-100 rule. Without it the engine would
+      # infer the same thing from the `pct` token in the name, which is how
+      # this line worked before the field existed -- correctly, and by accident.
+      - name: level_pct_redundant
+        type: NUMERIC
+        role: percentage
+        axioms: [CONSISTENCY]
+        window: 15m
+
+    Pump:
+      # STABILITY -- does it settle, or hunt?
+      - name: speed_rpm
+        type: NUMERIC
+        axioms: [STABILITY, BOUNDEDNESS]
+        warning: 2800
+        critical: 3200
+        window: 30m
+
+      # MONOTONICITY -- a lifetime counter may only rise. allow_reset covers
+      # the genuine restart case rather than treating it as a violation.
+      - name: run_hours_total
+        type: NUMERIC
+        axioms: [MONOTONICITY]
+        window: 24h
+        monotonicity:
+          direction: increasing
+          allow_reset: true
+
+      # CONNECTIVITY -- a pump with nothing to feed is a modelling error.
+      - name: feeds_a_tank
+        type: RELATIONSHIP
+        axioms: [CONNECTIVITY]
+        target_type: Tank
+        relation_type: feeds
+        min_cardinality: 1
+        max_cardinality: 2
+        violation_severity: HIGH
+
+    Controller:
+      # RESPONSIVENESS -- the deadline is part of the claim.
+      #
+      # `role:` IS WHAT MAKES THIS EVALUATE. RESPONSIVENESS and CONSISTENCY are
+      # about a KIND of quantity -- a latency, a count, a percentage, a ratio --
+      # so the model says which, and the checker no longer has to guess from
+      # English. Leave `role:` out and the engine still infers one from the
+      # name, so older models keep working; but an indicator whose name carries
+      # no recognised word then declines `not_applicable` while the pass stays
+      # green.
+      #
+      # This file worked around that by RENAMING: it read `setpoint_error_pct`
+      # until 2026-08-14, which could never fire, and was then renamed to
+      # `setpoint_response_error_pct` so the guess would land. Renaming a domain
+      # concept to satisfy a checker is the wrong remedy, and the name is back.
+      # `model_describe(s)` lists any declaration that cannot fire, so this is
+      # answerable without running a cycle.
+      - name: setpoint_error_pct
+        type: NUMERIC
+        role: latency
+        axioms: [RESPONSIVENESS, HOMEOSTASIS]
+        warning: 5
+        critical: 12
+        window: 30m
+        timeout: 10m

arbiter_engine/fire_frequency.py

@@ -0,0 +1,252 @@
+"""FireFrequencyTracker — dedicated rolling-window fire counter.
+
+Per the FireCounterMixin (date-bucket Counter shape) was the
+v1 instrumentation; an internal ruling lands the dedicated v2 tracker with:
+
+- Per-(axiom, domain, indicator) granularity (the mixin only
+  tracked (domain) — an internal ruling adds the axiom + indicator dimensions
+  the state_api spec called for).
+- Deque-based exact rolling-window counting (no day-bucket
+  approximation; sliding window of arbitrary length).
+- -style cadence WARN on suspiciously high fire rates.
+
+An internal ruling landed that migration: the mixin is gone, and the reasoner records
+every axiom's fires into the shared tracker at its dispatch boundary. This
+module moved from ``reflection/`` to ``detection/`` at the same time, so the
+eight checkers can be counted without ``detection`` importing ``reflection`` —
+the two packages are otherwise decoupled, and ``detection`` is what becomes
+the extracted engine.
+
+API contract:
+
+- ``record_fire(axiom, domain, indicator=None, timestamp=None)``
+- ``get_fire_rate(axiom, domain, indicator=None, window=24h) -> int``
+- ``get_fires_by_axiom_domain(window=24h) -> Dict[axiom, Dict[domain, int]]``
+- ``get_fires_by_indicator(window=24h) -> Dict[(axiom, domain, indicator), int]``
+- ``prune(now=None)`` — evict entries older than retention
+- ``count()`` / ``clear()`` ops helpers
+
+Per read-only-by-design + hook-not-replicate principles:
+axiom checkers + reflection-side consumers both read this tracker;
+no shadow storage.
+"""
+
+import logging
+from collections import Counter, defaultdict, deque
+from datetime import datetime, timedelta
+from typing import Counter as TypedCounter
+from typing import DefaultDict, Deque, Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+# Default retention window — entries older than this are evicted
+# on prune. Generous default so the 24h get_fire_rate query never
+# misses entries due to clock skew.
+_DEFAULT_RETENTION = timedelta(days=2)
+
+
+class FireFrequencyTracker:
+    """per-(axiom, domain, indicator) rolling fire counter.
+
+    Args:
+        retention: keep entries this long; older entries evicted on
+            ``prune`` or ``record_fire``. Default 2 days.
+        warn_rate_per_hour: if a single (axiom, domain) bucket
+            exceeds this rate in the past 1h, emit a WARN cadence
+            (sibling to heartbeat WARN). Default 100/hr.
+        warn_repeat_every: every Nth warn triggers (first-
+            occurrence + every-Nth cadence). Default 10.
+    """
+
+    def __init__(
+        self,
+        retention: timedelta = _DEFAULT_RETENTION,
+        warn_rate_per_hour: int = 100,
+        warn_repeat_every: int = 10,
+    ):
+        self.retention = retention
+        self.warn_rate_per_hour = int(warn_rate_per_hour)
+        self.warn_repeat_every = int(warn_repeat_every)
+        # (axiom, domain, indicator) -> deque[datetime]
+        # indicator can be None — represented as "" in the key for
+        # hashability + deterministic comparison.
+        self._fires: DefaultDict[Tuple[str, str, str], Deque[datetime]] = (
+            defaultdict(deque)
+        )
+        # WARN cadence tracking — count (date_iso, axiom, domain) bucket.
+        self._warn_counts: TypedCounter = Counter()
+
+    @staticmethod
+    def _key(axiom: str, domain: Optional[str], indicator: Optional[str]) -> Tuple[str, str, str]:
+        return (str(axiom), str(domain or "unknown"), str(indicator or ""))
+
+    def record_fire(
+        self,
+        axiom: str,
+        domain: Optional[str] = None,
+        indicator: Optional[str] = None,
+        timestamp: Optional[datetime] = None,
+    ) -> None:
+        """Record one fire event.
+
+        Args:
+            axiom: Axiom name (e.g. ``"BOUNDEDNESS"``).
+            domain: Optional domain ID; None → "unknown" bucket.
+            indicator: Optional indicator name; None → empty bucket
+                (axiom-level total).
+            timestamp: Override clock for testing.
+        """
+        now = timestamp or datetime.utcnow()
+        key = self._key(axiom, domain, indicator)
+        self._fires[key].append(now)
+        self._prune_one(key, now)
+        # Cadence WARN if 1h rate exceeds threshold.
+        recent_1h = self._count_in_window(key, now - timedelta(hours=1), now)
+        if recent_1h >= self.warn_rate_per_hour:
+            self._maybe_warn(axiom, domain or "unknown", recent_1h, now)
+
+    def _prune_one(self, key: Tuple[str, str, str], now: datetime) -> None:
+        """Drop entries older than retention from one deque."""
+        cutoff = now - self.retention
+        dq = self._fires[key]
+        while dq and dq[0] < cutoff:
+            dq.popleft()
+        if not dq:
+            del self._fires[key]
+
+    def prune(self, now: Optional[datetime] = None) -> int:
+        """Evict every entry older than retention. Returns count removed."""
+        now = now or datetime.utcnow()
+        cutoff = now - self.retention
+        removed = 0
+        for key in list(self._fires.keys()):
+            dq = self._fires[key]
+            while dq and dq[0] < cutoff:
+                dq.popleft()
+                removed += 1
+            if not dq:
+                del self._fires[key]
+        return removed
+
+    def _count_in_window(
+        self,
+        key: Tuple[str, str, str],
+        cutoff: datetime,
+        now: datetime,
+    ) -> int:
+        """Count entries in `[cutoff, now]` for one key."""
+        dq = self._fires.get(key, deque())
+        # deque is sorted by insertion time (timestamps monotonic per
+        # _key); count entries >= cutoff.
+        return sum(1 for ts in dq if ts >= cutoff)
+
+    def get_fire_rate(
+        self,
+        axiom: str,
+        domain: Optional[str] = None,
+        indicator: Optional[str] = None,
+        window: timedelta = timedelta(hours=24),
+        now: Optional[datetime] = None,
+    ) -> int:
+        """Return fire count for ``(axiom, domain, indicator)`` over ``window``."""
+        now = now or datetime.utcnow()
+        cutoff = now - window
+        key = self._key(axiom, domain, indicator)
+        return self._count_in_window(key, cutoff, now)
+
+    def get_fires_by_axiom_domain(
+        self,
+        window: timedelta = timedelta(hours=24),
+        now: Optional[datetime] = None,
+    ) -> Dict[str, Dict[str, int]]:
+        """Return ``{axiom: {domain: total_count}}`` aggregated over indicators.
+
+        Sibling to ``FireCounterMixin.get_fire_counts_by_domain``;
+        provides the same surface so reflection state_api can swap to
+        this tracker without changing the API contract.
+        """
+        now = now or datetime.utcnow()
+        cutoff = now - window
+        out: DefaultDict[str, Counter] = defaultdict(Counter)
+        for (axiom, domain, _indicator), dq in self._fires.items():
+            count = sum(1 for ts in dq if ts >= cutoff)
+            if count > 0:
+                out[axiom][domain] += count
+        return {a: dict(c) for a, c in out.items()}
+
+    def get_fires_by_indicator(
+        self,
+        window: timedelta = timedelta(hours=24),
+        now: Optional[datetime] = None,
+    ) -> Dict[Tuple[str, str, str], int]:
+        """Return ``{(axiom, domain, indicator): count}`` over ``window``."""
+        now = now or datetime.utcnow()
+        cutoff = now - window
+        out: Dict[Tuple[str, str, str], int] = {}
+        for key, dq in self._fires.items():
+            count = sum(1 for ts in dq if ts >= cutoff)
+            if count > 0:
+                out[key] = count
+        return out
+
+    def count(self) -> int:
+        """Total retained events across all buckets."""
+        return sum(len(dq) for dq in self._fires.values())
+
+    def clear(self) -> int:
+        """Drop everything; returns count removed."""
+        n = self.count()
+        self._fires.clear()
+        self._warn_counts.clear()
+        return n
+
+    def _maybe_warn(
+        self,
+        axiom: str,
+        domain: str,
+        rate_1h: int,
+        now: datetime,
+    ) -> None:
+        """ first-occurrence + every-Nth WARN cadence."""
+        date_iso = now.date().isoformat()
+        warn_key = (date_iso, axiom, domain)
+        n = self._warn_counts[warn_key]
+        self._warn_counts[warn_key] += 1
+        if n == 0 or (self.warn_repeat_every > 0 and n % self.warn_repeat_every == 0):
+            logger.warning(
+                f"FireFrequencyTracker: high fire rate for "
+                f"({axiom}, {domain}) — {rate_1h} fires in past hour "
+                f"≥ warn_rate_per_hour={self.warn_rate_per_hour} "
+                f"(attempt #{n + 1} today)"
+            )
+
+
+# ---------------------------------------------------------------------------
+# the shared tracker every axiom checker records into.
+#
+# A module-level instance rather than a constructor argument, deliberately.
+# The eight checkers are built inside `UnifiedAxiomReasoner.__init__` with no
+# tracker in scope, and threading one through would mean changing that
+# signature plus every construction site — a wide change to a kernel class for
+# a metric nothing gates on. The mixin this replaces held per-checker state
+# and was read globally, so a shared instance is the same reachability with
+# one counter instead of eight.
+#
+# The tracker keys on (axiom, domain, indicator), so one instance holds every
+# axiom without collision. That is why v2 can be shared where v1 could not.
+_SHARED_TRACKER: Optional["FireFrequencyTracker"] = None
+
+
+def get_shared_tracker() -> "FireFrequencyTracker":
+    """The process-wide fire counter. Created on first use."""
+    global _SHARED_TRACKER
+    if _SHARED_TRACKER is None:
+        _SHARED_TRACKER = FireFrequencyTracker()
+    return _SHARED_TRACKER
+
+
+def reset_shared_tracker() -> None:
+    """Drop the shared tracker. For tests that need isolation between cases."""
+    global _SHARED_TRACKER
+    _SHARED_TRACKER = None

arbiter_engine/history/__init__.py

@@ -0,0 +1,12 @@
+"""
+History module for observation storage.
+
+Provides:
+- ObservationHistory: Store and query historical observations
+- AxiomReadinessTracker: Track axiom readiness per entity
+"""
+
+from .observation import InMemoryObservationHistory
+from .readiness import AxiomReadinessTracker
+
+__all__ = ['InMemoryObservationHistory', 'AxiomReadinessTracker']