arbiter-engine 0.2.7__tar.gz → 0.2.9__tar.gz

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/.github/workflows/release.yml

@@ -109,15 +109,26 @@ jobs:
           GH_TOKEN: ${{ github.token }}
         run: gh release upload "$GITHUB_REF_NAME" dist/* --clobber
 
-      # PUBLISHING IS OFF UNTIL THE INDEX SIDE EXISTS, and the marker is a file
-      # rather than a setting so the change that turns it on is reviewable.
+      # PUBLISHING IS DONE BY HAND, BY RULING, and the marker is a file rather
+      # than a setting so the change that turns it back on is reviewable.
       #
-      # Trusted Publishing needs a publisher registered on PyPI naming this
-      # repository, this workflow file and this environment. Until that is
-      # registered, minting fails -- and a job that is red on every release day
-      # is one people learn to skip, which is the argument `verify-published.yml`
-      # already makes about itself. So: build and attach always, publish only
-      # when the marker says the other side is ready.
+      # It was ON from 2026-09-03 to 2026-09-25 and never published a file. The
+      # job below runs on the TAG; the release runbook uploads BEFORE the tag,
+      # so the repository never advertises a version the index does not serve.
+      # For a release made that way the publish job can only ever meet a version
+      # already on the index, so approving it could only fail -- and fourteen tag
+      # runs, v0.1.11 through v0.2.7, sat waiting with no conclusion instead.
+      # That is the two paths being mutually exclusive, not somebody forgetting
+      # to click.
+      #
+      # BOTH SETTINGS IT NEEDS STILL EXIST, and settings do not show in a diff,
+      # so they are stated here rather than lost with the marker. A `pypi`
+      # environment with a required reviewer (measured 2026-09-25), and a PyPI
+      # trusted publisher naming this repository, this workflow and that
+      # environment (verified at registration on 2026-09-03; no upload has ever
+      # used it). Turning publishing back on is a change to the UPLOAD ORDER
+      # first -- tag, then publish -- and the marker second. The marker alone
+      # restores exactly the waits described above.
       - name: Is publishing from CI enabled?
         id: gate
         run: |
@@ -126,12 +137,13 @@ jobs:
           else
             echo "enabled=false" >> "$GITHUB_OUTPUT"
             echo "::notice::CI built these artifacts from the tag and attached them" \
-                 "to the Release. Publishing to the index is still done by hand." \
-                 "To hand it over: create the 'pypi' environment in this" \
-                 "repository's settings, register a PyPI trusted publisher naming" \
-                 "this repository, release.yml and that environment, then add" \
-                 ".github/PUBLISH_FROM_CI. The publish job stays behind the" \
-                 "environment's approval either way."
+                 "to the Release. Publishing to the index is done by hand, before" \
+                 "the tag, so this repository never advertises a version the index" \
+                 "does not serve. The 'pypi' environment and the PyPI trusted" \
+                 "publisher both still exist. To hand publishing to CI, change the" \
+                 "release order to tag-then-publish FIRST, then add" \
+                 ".github/PUBLISH_FROM_CI: the marker alone brings back a publish" \
+                 "job that can only meet a version already on the index."
           fi
 
       # The bytes that were attached, kept for the publish job. NOT a rebuild

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/CHANGELOG.md

@@ -34,6 +34,65 @@ useful-looking document and the less trustworthy one.
 
 ## [Unreleased]
 
+## [0.2.9] — 2026-09-25
+
+### Fixed
+
+- **`model_describe` and `gaps` work over every history this package ships.**
+  Both asked the session's history for `series_keys()`, which only the
+  in-memory store implemented, so a session built over
+  `SqliteObservationHistory` or `CalendarHistory` raised `AttributeError`, and
+  `rollout` ran with no seeded past (`precondition_unmet`). Both stores now list
+  their series. A history of the caller's own that implements only the five
+  `ObservationHistory` methods gets `unconsumed_observations: None` -- the report
+  could not be made -- rather than a crash or an empty list.
+- **A forecast is graded through whatever history the session reads.** The
+  ledger read the in-memory store's private series and skipped any other, so
+  a forecast made over `SqliteObservationHistory`, in a model declaring a
+  `calendar:`, or in a model with any derived indicator matured `ungradeable`
+  every time: measured, none of twelve graded in each case, against twelve of
+  twelve on the plain store. It reads through `get_values` now, and all four
+  grade alike. No calibration figure moves for a session that graded before.
+
+## [0.2.8] — 2026-09-25
+
+### Added
+
+- **`target_reading_set_aside` (`TARGET_READING_SET_ASIDE`), a stamp on every
+  `inference` answer whose target had a reading of its own.** `infer` answers whether everything ELSE implicates
+  the target, so the target's own reading is left out -- and nothing said so. A
+  supply at 9.0 kV, below its own critical floor, got the posterior it gets at a
+  healthy 11.0 kV. `checked.target_reading` now carries what the reading would
+  have set (`faulty` or `clean`) and the target's own worst severity at any
+  level. No posterior changes.
+- **Each `hypothesize` candidate carries `own_reading`**, the same row for that
+  candidate: `None` when it was unread, which is the case `evidence_needed` is
+  written for. Measured before it: a feeder read CLEAN ranked first at 0.962
+  with its own current named as the evidence needed.
+
+### Fixed
+
+- **`hypothesize` carries the stamps of the inferences behind its ranking.** It
+  dropped all of them, so a ranking computed against this engine's default
+  evidence floor arrived without `evidence_severity_not_declared`, while the
+  verb's own docstring told the reader to check for that stamp.
+- **An intervention on the target answers exactly.** `infer(t, do={t: v})`
+  returned the same posterior for `v = 0` and `v = 1` (0.984981 on the
+  specimen), because the forced value was set aside with the reading. It
+  returns `v` now, with method `intervention`, and files nothing.
+- **Twelve published sentences that read as broken English.** Seven docstrings
+  and comments (`Until this returned two values`, `the ONLY rule until, and`)
+  and five lines of `evidence/` (`the recursive-examination framework
+  framework`) came out of the step that removes internal references. They now
+  read as sentences. No behaviour changes.
+
+### Changed
+
+- **Releases are uploaded to the index by hand, and `.github/PUBLISH_FROM_CI` is
+  retired.** The CI publish job it enabled runs on the tag, after the upload the
+  release procedure makes first, so it never published a file. CI still builds
+  each release from its tag and attaches the files to the GitHub Release.
+
 ## [0.2.7] — 2026-09-25
 
 ### Added

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/CITATION.cff

@@ -9,7 +9,7 @@ authors:
     alias: "james-sheen"
   - name: "The Arbiter Project Authors"
 license: Apache-2.0
-version: "0.2.7"
+version: "0.2.9"
 date-released: "2026-09-25"
 repository-code: "https://github.com/james-sheen/arbiter"
 url: "https://github.com/james-sheen/arbiter"

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/MODELING.md

@@ -1105,7 +1105,18 @@ this is a verb rather than a filter over `traverse`. On the shipped specimen,
 asking about the supply with the feeder OBSERVED faulty gives 0.679054 and with
 the feeder FORCED faulty gives 0.05 -- the same node in the same state, a factor
 of thirteen apart. Seeing a thing fail is evidence about what feeds it; breaking
-it yourself is not.
+it yourself is not. Forcing the TARGET itself answers exactly: `do={t: v}`
+returns `v`, method `intervention`.
+
+**The target's own reading is not evidence about the target.** `infer` asks
+whether everything ELSE implicates it, because conditioning on its own state
+would answer 1 or 0 by construction. So a supply in critical breach and the
+same supply healthy get one posterior between them -- correct for that
+question, and the answer says so: `target_reading_set_aside` is stamped whenever
+the target had a reading, and `checked.target_reading` names the state it would
+have set and the target's own worst severity. `hypothesize` carries the same
+row per candidate as `own_reading`, so a candidate the graph implicates can be
+read beside what its own meter already said.
 
 ### What counts as faulty evidence: `causal.evidence_severity`
 
@@ -1249,7 +1260,8 @@ which number to distrust.
 They arrive in an `assumptions` list on the `simulation` and `plan`
 sub-envelopes, and on each `plan` candidate where the candidates differ. An
 EMPTY list means the engine made none of them, which is a different claim from
-the key being absent.
+the key being absent. The `inference` sub-envelope -- what `infer` and
+`hypothesize` return -- carries the list only when it has something in it.
 
 | stamp | what it discloses |
 |---|---|
@@ -1257,6 +1269,7 @@ the key being absent.
 | `time_course_not_declared` | the time course crossed was not declared; this engine supplied a delay or a time constant, or both |
 | `evidence_severity_not_declared` | `infer` read the last check against THIS engine's severity floor, because the model declared none. Declare `causal.evidence_severity:` to choose it |
 | `evidence_severity_unusable` | the model DID declare `causal.evidence_severity:` and this engine could not use it, so the floor above was its own. Carried beside the stamp above, never instead of it; `model_describe` names the value that was refused |
+| `target_reading_set_aside` | the queried entity had a reading of its own and the posterior was computed without it -- the question answered is whether everything else implicates it. `checked.target_reading` says what the reading would have set, and the target's own worst severity |
 | `steady_state_reached` | the horizon outlasted the transient, so the value reported is the settled one |
 | `series_edges_composed_exactly` | two couplings in series were composed by the exact cascade response |
 | `series_edges_compose_by_product` | two couplings in series were composed by multiplying response fractions, which is an approximation |

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arbiter-engine
-Version: 0.2.7
+Version: 0.2.9
 Summary: A detection engine that reports what it did not check.
 Project-URL: Homepage, https://github.com/james-sheen/arbiter
 Project-URL: Source, https://github.com/james-sheen/arbiter

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/api.py

@@ -536,7 +536,7 @@ class EngineSession:
                 })
         return records
 
-    def unconsumed_observations(self) -> List[Dict[str, Any]]:
+    def unconsumed_observations(self) -> Optional[List[Dict[str, Any]]]:
         """Series this session holds that no declared indicator will ever read.
 
         This rules the second half of issue #1. ``add_observations``
@@ -564,9 +564,18 @@ class EngineSession:
         # report on the other input surface counted them as read. One
         # declaration, two verdicts, and the only way to silence the wrong one
         # was to declare the property a second time.
+        # A HISTORY THAT CANNOT LIST ITS SERIES CANNOT BE ASKED
+        # THIS, and the answer says so rather than crashing or claiming the
+        # empty list. `series_keys` is not one of the ABC's five methods; both
+        # stores this engine ships implement it, and a caller's own need not.
+        # `None` is the engine's convention for *not measured*, and every
+        # consumer in the family already reads this key through `or []`.
+        keys = getattr(self.history, "series_keys", None)
+        if keys is None:
+            return None
         declared: Dict[str, set] = self.readable_properties()
         records: List[Dict[str, Any]] = []
-        for entity_id, prop in self.history.series_keys():
+        for entity_id, prop in keys():
             entity = self.entities.get(entity_id)
             if entity is None:
                 reason = "unknown_entity"
@@ -2526,7 +2535,19 @@ def hypothesize(session: EngineSession, entity_id: str,
     specimen: with both panels in the warning band the supply outranks the
     feeder 0.0104 to 0.0018, and with both below critical the feeder ranks first
     at 0.962. Same topology, same question, opposite answers — so read the
-    `evidence_severity_not_declared` stamp before reading this ranking.
+    `evidence_severity_not_declared` stamp before reading this ranking. Since
+     the ranking carries it: every stamp an inference behind a candidate
+    applied rides on `hypothesis.assumptions`. Before that the verb dropped
+    them, and this paragraph told the reader to look for a stamp that was never
+    there.
+
+    **A candidate's own reading is not part of its score.** Each posterior
+    answers whether the REST of the graph implicates that candidate, and
+    `own_reading` says what the candidate's own meter already said -- `None`
+    when unread, which is the case `evidence_needed` is for. Measured: a feeder
+    read clean at 300 A ranked first at 0.962 with its own current named as the
+    evidence needed. The ranking is right about the graph; the row now shows
+    the reading beside it.
     """
     from arbiter_engine.inference.hypothesis import (
         hypothesize as _hypothesize)
@@ -2586,6 +2607,18 @@ def infer(session: EngineSession, target: str,
     Without `report_above` there is no finding, on the same rule as `project`
     and `discover`: the posterior is computed and reported, and whether it is
     alarming is not the engine's to decide.
+
+    THE TARGET'S OWN READING IS NOT EVIDENCE. The question answered is whether
+    everything ELSE implicates the target -- conditioning on its own state would
+    return 1 or 0 by construction. When the target had a reading, the answer is
+    stamped `target_reading_set_aside` and `checked.target_reading` says what
+    the reading would have set (`faulty` or `clean`) and the target's own worst
+    severity at any level. A supply in critical breach and the same supply
+    healthy get one posterior between them; that is correct for the question,
+    and until a later change nothing on the answer said which question it was.
+
+    An intervention on the target itself answers exactly: `do={t: v}` returns
+    `v`, method `intervention`, and files nothing.
     """
     if session.model is None:
         return unavailable_envelope("no domain model loaded")

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/assumptions.py

@@ -6,7 +6,7 @@ not a warning and not a finding: it is the engine saying which of its own
 choices the value in front of you depends on, so that a reader who disagrees
 with the choice knows which number to distrust.
 
-WHY THEY LIVE HERE. Until they lived as bare string literals at twenty
+WHY THEY LIVE HERE. Until a later change they lived as bare string literals at twenty
 sites across four modules, and nothing anywhere held the list. The cost was not
 hypothetical. An outside comparison of this engine reproduced all three of its
 ENUMERATED vocabularies exactly -- the fourteen decline reasons, the six gap
@@ -85,6 +85,23 @@ EVIDENCE_SEVERITY_NOT_DECLARED = "evidence_severity_not_declared"
 #: duplicate what is there.
 EVIDENCE_SEVERITY_UNUSABLE = "evidence_severity_unusable"
 
+#: The queried entity had a reading of its own, and the posterior was computed
+#: WITHOUT it. `infer` answers *does the rest of the graph implicate this
+#: entity*, which is the informative question -- conditioning on the target's
+#: own state would answer 1 or 0 by construction -- and the engine chose that
+#: question on the caller's behalf. What the reading said is on the answer as
+#: `checked.target_reading`: the state it would have set, and the target's own
+#: worst severity at any level.
+#:
+#:, and it went unsaid for as long as the verb has existed. Measured on
+#: the substation specimen with the feeder unread: the supply at 9.0 kV, below
+#: its own critical floor, gets exactly the posterior it gets at a healthy
+#: 11.0 kV, 0.670634 both times, because the one reading that would have
+#: settled the question was the one left out. The other direction is worse. A feeder READ CLEAN is ranked
+#: first by `hypothesize` at 0.962 with its own meter named as the evidence
+#: needed -- the reading it had already taken and set aside.
+TARGET_READING_SET_ASIDE = "target_reading_set_aside"
+
 #: The horizon was long enough that the transient had finished, so the value
 #: reported is the steady state rather than a point on the way to it.
 STEADY_STATE_REACHED = "steady_state_reached"
@@ -239,6 +256,7 @@ ASSUMPTION_STAMPS: Tuple[str, ...] = (
     TIME_COURSE_NOT_DECLARED,
     EVIDENCE_SEVERITY_NOT_DECLARED,
     EVIDENCE_SEVERITY_UNUSABLE,
+    TARGET_READING_SET_ASIDE,
     STEADY_STATE_REACHED,
     SERIES_EDGES_COMPOSED_EXACTLY,
     SERIES_EDGES_COMPOSE_BY_PRODUCT,

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/examples/water_tank.yaml

@@ -75,7 +75,7 @@ domain:
       #
       # The role rule is single-value: `role: percentage` range-checks this
       # reading against 0-100 and would behave identically if `level_pct` were
-      # deleted from the model. That was the ONLY rule until, and this
+      # deleted from the model. That was the ONLY rule until a later change, and this
       # comment said `two independent readings that should agree` until
       # 2026-08-16 -- the reading the use-case catalogue carried in eleven
       # places, and the reason both were reported from outside on the same day.

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/history/calendar.py

@@ -226,3 +226,8 @@ class CalendarHistory(ObservationHistory):
 
     def get_observation_count(self, entity_id: str, property_name: str) -> int:
         return self.inner.get_observation_count(entity_id, property_name)
+
+    def series_keys(self):
+        """The series the history underneath holds -- a calendar changes which
+        instants count, never which series exist."""
+        return self.inner.series_keys()

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/history/sqlite_store.py

@@ -135,6 +135,24 @@ class SqliteObservationHistory(ObservationHistory):
         return [(_from_seconds(ts), text if text is not None else str(number))
                 for ts, number, text in rows]
 
+    def series_keys(self) -> List[Tuple[str, str]]:
+        """Every ``(entity_id, property_name)`` this store holds a series for.
+
+        Not one of the ABC's five, and the in-memory store had it
+        from on -- so every reader that enumerates a history was
+        written against the default and this class was never asked. Two of
+        them crashed on it: `model_describe` and `gaps` raised AttributeError
+        for any session built over this store, and `rollout` ran with no
+        imagined past behind it, declining `precondition_unmet`. Nothing
+        downstream had constructed one until a vertical kept its readings
+        across runs, which is the one use this class exists for.
+        """
+        with self._lock:
+            rows = self._connection.execute(
+                "SELECT DISTINCT entity_id, property FROM obs"
+                " ORDER BY entity_id, property").fetchall()
+        return [(str(entity_id), str(prop)) for entity_id, prop in rows]
+
     def get_observations(self, entity_id: str, start: datetime,
                          end: datetime) -> List[Observation]:
         with self._lock:

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/inference/hypothesis.py

@@ -46,6 +46,7 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, Set, Tuple
 
+from ..assumptions import ASSUMPTION_STAMPS
 from ..subenvelope import Decline, SubEnvelope
 from .causal import CausalGraph, causal_subgraph
 from .runner import Query, run_inference
@@ -151,10 +152,18 @@ def hypothesize(session: Any, entity_id: str, *,
         return SubEnvelope("inference", checked, not_checked=declines), []
 
     ranked: List[Dict[str, Any]] = []
+    # THE STAMPS OF EVERY INFERENCE THIS RANKING RESTS ON. Each
+    # candidate is scored by `run_inference`, which stamps the defaults it
+    # applied; this verb used to drop them all, so a ranking computed against
+    # the engine's evidence floor carried no `evidence_severity_not_declared`
+    # while the verb's own docstring told the reader to check for it.
+    stamps: set = set()
     for node, hops in candidates:
         sub = run_inference(session, Query(target=node), report_above=None)
         payload = sub.to_dict()
-        posterior = (payload.get("checked") or {}).get("posterior")
+        checked_here = payload.get("checked") or {}
+        posterior = checked_here.get("posterior")
+        stamps.update(payload.get("assumptions") or ())
         entity_type = graph.entity_type.get(node, "")
         properties = _readable_properties(session.model, entity_type)
         ranked.append({
@@ -165,6 +174,13 @@ def hypothesize(session: Any, entity_id: str, *,
             # The FIRST declared readable property, which is the model's own
             # ordering rather than this verb's opinion about which matters.
             "evidence_needed": (f"{node}.{properties[0]}" if properties else None),
+            # WHAT THAT READING ALREADY SAID, when it was taken. The
+            # posterior above leaves the candidate's own reading out, which is
+            # what makes it a ranking at all; without this row a feeder READ
+            # CLEAN came back first at 0.962 with its own meter as the evidence
+            # needed, sending an operator to take a reading already taken.
+            # `None` means unread -- the case `evidence_needed` is written for.
+            "own_reading": checked_here.get("target_reading"),
             "test_action": _test_action(session.model, entity_type),
         })
 
@@ -179,4 +195,9 @@ def hypothesize(session: Any, entity_id: str, *,
                   if r["posterior"] is not None and r["posterior"] >= report_above]
         checked["reported"] = len(ranked)
 
-    return SubEnvelope("inference", checked, not_checked=declines), ranked
+    # In the vocabulary's own order, so one set of findings always reports one
+    # list; a stamp outside the published tuple sorts last rather than vanishing.
+    order = {stamp: i for i, stamp in enumerate(ASSUMPTION_STAMPS)}
+    assumptions = tuple(sorted(stamps, key=lambda s: (order.get(s, len(order)), s)))
+    return (SubEnvelope("inference", checked, not_checked=declines,
+                        assumptions=assumptions), ranked)

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/inference/runner.py

@@ -23,7 +23,8 @@ from typing import (Any, Dict, FrozenSet, List, Optional, Sequence, Set,
                     Tuple)
 
 from ..assumptions import (EVIDENCE_SEVERITY_NOT_DECLARED,
-                           EVIDENCE_SEVERITY_UNUSABLE)
+                           EVIDENCE_SEVERITY_UNUSABLE,
+                           TARGET_READING_SET_ASIDE)
 from ..subenvelope import Decline, SubEnvelope
 from ..twin.gap import GAP_CONFIDENCE_THRESHOLDS as _GAP_WEIGHT
 from ..twin.topology import GapType, TopologyGap, TopologyQuestion
@@ -79,7 +80,7 @@ def evidence_severities(model) -> Tuple[FrozenSet[str], bool, bool]:
     see; `[critical, hihg]` therefore becomes the default rather than quietly
     becoming `[critical]`.
 
-    `unusable` SEPARATES TRYING FROM NOT TRYING. Until this returned
+    `unusable` SEPARATES TRYING FROM NOT TRYING. Until a later change this returned
     two values and an author who mistyped a severity got the same bare
     `evidence_severity_not_declared` as one who declared nothing -- the reading
     an outside review reproduced was *not declared*, therefore *my file did not
@@ -137,6 +138,40 @@ def evidence_from(session, graph: CausalGraph,
     return observed, unobserved
 
 
+#: Severity order for reporting the worst one, most urgent first. Ties in
+#: `priority_score` (WARNING and MEDIUM share one) fall to declaration order, so
+#: the same findings always report the same word.
+_SEVERITY_ORDER: Tuple[Severity, ...] = tuple(Severity)
+
+
+def _own_severity(session, entity_id: str) -> Optional[str]:
+    """The most urgent severity the last check gave `entity_id`, at ANY level.
+
+    Deliberately not filtered by the evidence floor. A panel carrying a warning
+    under an engine floor of `high` counted as CLEAN, and a reader looking at
+    the set-aside reading is owed both facts -- what the floor made of it and
+    what the check actually said -- or *clean* reads as *nothing was found*.
+    """
+    result = getattr(session, "_last_result", None)
+    if result is None:
+        return None
+    worst: Optional[Severity] = None
+    for problem in list(getattr(result, "problems", ()) or ()) + \
+            list(getattr(result, "warnings", ()) or ()):
+        if str(getattr(problem, "entity_id", "")) != entity_id:
+            continue
+        raw = getattr(problem, "severity", None)
+        try:
+            severity = Severity(str(getattr(raw, "value", raw)).lower())
+        except ValueError:
+            continue
+        if worst is None or (
+                (severity.priority_score, _SEVERITY_ORDER.index(severity))
+                < (worst.priority_score, _SEVERITY_ORDER.index(worst))):
+            worst = severity
+    return None if worst is None else worst.value
+
+
 def _surgery(graph: CausalGraph, do: Dict[str, int]) -> CausalGraph:
     """Cut the incoming edges of every intervened node. THIS is the difference
     between `do(x)` and observing x, and the reason a hypothetical cannot be
@@ -220,6 +255,22 @@ def run_inference(session, query: Query,
             evidence={"cycle": loop}))
         return SubEnvelope("inference", checked, findings, declines, questions)
 
+    # AN INTERVENTION ON THE TARGET IS THE ANSWER. `do(x=v)` sets x,
+    # so P(x faulty | do(x=v)) is v, whatever the evidence says and however the
+    # graph is wired. Until this branch the intervened value went into the
+    # evidence and was then popped with the target's reading below, so the
+    # surgery cut x's parents and the elimination answered for an x nobody had
+    # set: measured on the specimen, `do={fdr-1: 0}` and `do={fdr-1: 1}` both
+    # returned 0.984981. Answered here, BEFORE the backdoor check, because an
+    # answer that reads no edge cannot be unidentifiable. Nothing is filed and
+    # nothing is reported: a value the caller forced is not a prediction about
+    # the world, and a finding would report the caller's own act back to them.
+    if query.target in query.do:
+        checked["answered"] = 1
+        checked["method"] = "intervention"
+        checked["posterior"] = float(query.do[query.target])
+        return SubEnvelope("inference", checked, findings, declines, questions)
+
     working = _surgery(graph, query.do) if query.do else graph
     latent = _open_backdoor_latent(working, query)
     if latent is not None:
@@ -235,17 +286,34 @@ def run_inference(session, query: Query,
     observed, unobserved = evidence_from(session, working, severities)
     for node in query.do:
         observed[node] = query.do[node]
-    observed.pop(query.target, None)
+    # The target's own state is left out, because conditioning on it answers 1
+    # or 0 by construction. What is asked is whether EVERYTHING ELSE implicates
+    # it -- and since the answer says that is what was asked.
+    set_aside = observed.pop(query.target, None)
     checked["evidence"] = len(observed)
     checked["unobserved"] = len(unobserved)
     # from here down the answer depends on WHICH severities counted
-    # as faulty, so every exit below carries the disclosure. The two returns
+    # as faulty, so every exit below carries the disclosure. The returns
     # above this line are refusals decided from the GRAPH alone -- a cycle, an
-    # open backdoor -- and read no evidence, so stamping them would name a
-    # choice that did not touch the answer.
+    # open backdoor -- or an intervention that fixes the answer, and read no
+    # evidence, so stamping them would name a choice that did not touch it.
     stamps: Tuple[str, ...] = () if floor_declared else (
         (EVIDENCE_SEVERITY_NOT_DECLARED,)
         + ((EVIDENCE_SEVERITY_UNUSABLE,) if floor_unusable else ()))
+    # AND WHICH READING WAS NOT USED. A target in breach answered
+    # exactly as a healthy one did, with nothing on the envelope saying its own
+    # reading had been excluded: measured, the supply at 9.0 kV and at 11.0 kV
+    # both 0.670634. Stamped whenever the target HAD a reading, clean as well
+    # as faulty -- a clean reading set aside misleads just as far, the other
+    # way. `severity` is the target's own worst finding at any level, beside
+    # the state the evidence floor made of it, because under the engine's floor
+    # a warning counts as clean and *clean* alone would read as *nothing found*.
+    target_reading: Optional[Dict[str, Any]] = None
+    if set_aside is not None:
+        target_reading = {"state": "faulty" if set_aside else "clean",
+                          "severity": _own_severity(session, query.target)}
+        checked["target_reading"] = target_reading
+        stamps = stamps + (TARGET_READING_SET_ASIDE,)
 
     relevant = _relevant_edges(working, query, observed)
     defaulted = sorted(f"{s}->{t}" for (s, t) in relevant
@@ -313,14 +381,14 @@ def run_inference(session, query: Query,
     elif posterior >= report_above:
         findings.append(_posterior_finding(
             session, working, query, posterior, observed, unobserved,
-            report_above))
+            report_above, target_reading))
 
     return SubEnvelope("inference", checked, findings, declines, questions,
                        assumptions=stamps)
 
 
 def _posterior_finding(session, graph, query, posterior, observed,
-                       unobserved, report_above):
+                       unobserved, report_above, target_reading=None):
     from ..interfaces import Problem
     entity = session.entities.get(query.target)
     return Problem.from_entity(
@@ -335,6 +403,9 @@ def _posterior_finding(session, graph, query, posterior, observed,
                   "cpt_sources": graph.sources(),
                   "evidence_set": sorted(observed),
                   "unobserved": sorted(unobserved),
+                  # a finding travels without its envelope, so the
+                  # reading it did not use travels with it.
+                  "target_reading": target_reading,
                   "root_prior": ROOT_PRIOR,
                   "root_prior_source": "default",
                   "do": dict(query.do)})

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/residual/predict_vs_mirror.py

@@ -48,7 +48,7 @@ import uuid
 from collections import deque
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from ..clock import as_naive_utc, now_utc
+from ..clock import as_naive_utc, as_of, now_utc
 # the id the yardstick is filed under, read from the module that
 # owns it rather than re-spelled here. Two spellings of one literal is how
 # the exclusion below would silently stop excluding anything.
@@ -698,18 +698,47 @@ class PredictionLedger:
         property_name: str,
         start: datetime,
         end: datetime,
+        now: Optional[datetime] = None,
     ) -> List[Tuple[datetime, float]]:
-        """Numeric observations for (entity, property) in [start, end],
-        read defensively from the in-memory histories."""
+        """Numeric observations for (entity, property) in [start, end], read
+        through each history's own `get_values` -- never its internals.
+
+        This read the in-memory store's private `_history` dict and
+        SKIPPED any history without one. `check` hands the ledger the session's
+        READING history, which is the raw store only when the model declares
+        neither a calendar nor a derived indicator; otherwise it is a view, and
+        so is the durable store. Measured, the same twenty minutes of one tank
+        filing a forecast a minute: the in-memory store graded 12 of 12; the
+        durable store, a declared calendar and a model with one derived
+        indicator graded NONE, all twelve `ungradeable`. A calibration figure
+        that could never be anything but empty, reported without an error --
+        beside a comment in `check` saying the view was passed so that a
+        derived forecast WOULD have something to score against.
+
+        `get_values` is the one reader every history implements, and it ends
+        at the engine's clock -- so the read is pinned to the GRADING instant,
+        `now`, which a caller may pass explicitly and which the private dict
+        never consulted. The window reaches back to `start`, a microsecond
+        wider because the stores bound it exclusively, and is then cut to
+        exactly `[start, end]`. A calendar view answers a window in OPEN time,
+        which reaches further back in wall time, and the cut is what makes
+        that harmless.
+        """
         out: List[Tuple[datetime, float]] = []
-        for history in histories or []:
-            raw = getattr(history, "_history", None)
-            if not isinstance(raw, dict):
-                continue
-            for ts, value in raw.get((entity_id, property_name)) or []:
-                if (isinstance(ts, datetime) and isinstance(value, (int, float))
-                        and start <= ts <= end):
-                    out.append((ts, float(value)))
+        at = as_naive_utc(now) if now is not None else now_utc()
+        span = at - start + timedelta(microseconds=1)
+        if span.total_seconds() <= 0:
+            return out
+        with as_of(at):
+            for history in histories or []:
+                reader = getattr(history, "get_values", None)
+                if reader is None:
+                    continue
+                for ts, value in reader(entity_id, property_name, span) or []:
+                    if (isinstance(ts, datetime)
+                            and isinstance(value, (int, float))
+                            and start <= ts <= end):
+                        out.append((ts, float(value)))
         return out
 
     def _grade_distribution_record(
@@ -743,7 +772,7 @@ class PredictionLedger:
             return None
         observations = self._observations_for(
             list(histories), record.entity_id, record.indicator or "",
-            record.predicted_at, window_end)
+            record.predicted_at, window_end, now)
         if not observations:
             record.verdict = GRADE_UNGRADEABLE
             record.graded_at = now
@@ -779,7 +808,7 @@ class PredictionLedger:
             return None
         observations = self._observations_for(
             list(histories), record.entity_id, record.indicator or "",
-            record.predicted_at, window_end)
+            record.predicted_at, window_end, now)
         target = record.predicted_at + timedelta(seconds=record.horizon_s)
         # AND EACH READING GRADES ONE HORIZON, not every horizon
         # whose window contains it. This took the observation closest to the

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/scripts/benchmark_check.py

@@ -138,7 +138,7 @@ def build(entities: int, observations: int, breach_fraction: float):
     """A fresh session with `entities` units, a `breach_fraction` of them bad.
 
     Returns the session and the two halves of its construction cost SEPARATELY.
-    They were one number until, and the number was unreadable: loading
+    They were one number until a later change, and the number was unreadable: loading
     the model is flat in ENTITY count -- it loads a model, not entities -- while
     the feed is linear, so a single `build` figure hides which half a consumer
     pays again on the next cycle. That is the question the cost table gets

{arbiter_engine-0.2.7 → arbiter_engine-0.2.9}/arbiter_engine/twin/traverser.py

@@ -1744,7 +1744,7 @@ class TopologyTraverser:
         builder seeded, which is how a walk that evaluated one invariant came
         to report four.
 
-        **BOUNDEDNESS only** — and, until, only HALF of BOUNDEDNESS.
+        **BOUNDEDNESS only** — and, until a later change, only HALF of BOUNDEDNESS.
         The body compared against `warning` and `critical` and never against
         `lower_warning` / `lower_critical`, so a declared FLOOR was invisible
         here while `UnifiedAxiomReasoner` reported it: a traversal over a