arbiter-engine 0.2.6__tar.gz → 0.2.8__tar.gz

{arbiter_engine-0.2.6 → arbiter_engine-0.2.8}/.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.6 → arbiter_engine-0.2.8}/CHANGELOG.md

@@ -34,7 +34,81 @@ useful-looking document and the less trustworthy one.
 
 ## [Unreleased]
 
-_Nothing yet._
+## [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
+
+- **Every fitted transition proposal now carries a `replay`**: what adopting it
+  would have caught, as counts against the corpus that recorded what happened.
+  `n` and `r_squared` say how well a gain fits the data it was fitted on, which
+  is a different question.
+- **`replay_unavailable` (`REPLAY_UNAVAILABLE`) is the answer when no corpus was
+  supplied.** It carries its reason and no counts: a proposal nobody could test
+  is not a proposal that failed, and a zero cannot tell those apart. No rate is
+  reported, for the reason the surprise score reports none.
+- **`hypothesize(session, entity_id)` — what could explain a finding, ranked.**
+  The inverse of `gaps`: that verb says what the model does not declare, this
+  says what the world might be doing given what it does. Each candidate is a
+  DECLARED causal ancestor, scored by the same inference `infer` runs, carrying
+  the reading that would discriminate it and the declared action that could test
+  it. `MAX_HOPS` bounds the walk. It ranks nothing the author did not connect.
+- **`arbiter_engine.producers.baseline_learner`, a reference producer.** A
+  damped-trend exponential smoother, shipped because the engine's own baseline
+  is a random walk and a random walk is the right floor and a poor opponent. It
+  gets no privilege: it reads a session through `reading_history()` and files
+  through `ingest_forecasts` like any outside forecaster. `MINIMUM_POINTS` is
+  the series length below which it returns nothing rather than a fitted number.
+- **`model_describe(session, surprises=...)`** takes the corpus to replay
+  against. The model is restored afterwards whether or not the replay ran --
+  deriving and adopting stay separate.
+
+### Changed
+
+- **The proposal surface now records WHO may write a fitted gain down, and it
+  is not this package.** A tool downstream -- a separate distribution, a
+  separate command, a proposal named by a person, a basis recorded in the file
+  -- may adopt one into a model it owns. Nothing here opens a model for
+  writing, and a test compares the file's bytes rather than reading this source
+  for a call. The first such writer is `bmc-sensor-audit adopt`.
 
 ## [0.2.6] — 2026-09-24
 

{arbiter_engine-0.2.6 → arbiter_engine-0.2.8}/CITATION.cff

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

{arbiter_engine-0.2.6 → arbiter_engine-0.2.8}/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.6 → arbiter_engine-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arbiter-engine
-Version: 0.2.6
+Version: 0.2.8
 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
@@ -514,7 +514,7 @@ The engine is open. The knowledge and the operations are not.
 
 ## Status
 
-**v0.2.** 95 Python files, 93 modules importing on the declared dependencies alone, 15 supported
+**v0.2.** 98 Python files, 96 modules importing on the declared dependencies alone, 15 supported
 names — **counted in this repository**, which is the package you are holding.
 
 That basis is stated because it is easy to get wrong in a way nobody notices. The build adds one
@@ -523,7 +523,7 @@ are holding — and this line published the smaller figure until 2026-08-12, whe
 falsify it with `find . -name '*.py' | wc -l`. A checkable false claim, in the Status section of a
 project whose subject is checkable claims. Count the artifact, never an earlier stage of it.
 
-The import figure carries the same hazard one layer down, and it depends on what you have installed. Sweeping the package where `scipy` happens to be present imports 94; on the declared dependencies alone it is the 93 above, because `propagation.lp_confidence` is the one module that needs `scipy` and it is a deep path outside the supported surface. Count the artifact **in the state the reader will have it**, not in the state the person measuring happens to be standing in — this line quoted the with-`scipy` figure until 2026-08-12, which no reader installing normally could reproduce.
+The import figure carries the same hazard one layer down, and it depends on what you have installed. Sweeping the package where `scipy` happens to be present imports 97; on the declared dependencies alone it is the 96 above, because `propagation.lp_confidence` is the one module that needs `scipy` and it is a deep path outside the supported surface. Count the artifact **in the state the reader will have it**, not in the state the person measuring happens to be standing in — this line quoted the with-`scipy` figure until 2026-08-12, which no reader installing normally could reproduce.
 
 **The supported-name count went stale in exactly the way this section warns about.** It read
 three short for the release that added `SqliteObservationHistory`, `SessionCalendar` and
@@ -540,7 +540,7 @@ committed by the paragraph. The figures are described here now rather than quote
 rule the changelog states for its own errata: a correction that reproduces the string it corrects
 is that string to a checker.
 
-**And the count is of SUBMODULES: the root package is not one of them.** Walking `arbiter_engine` for what it contains gives 93; adding the package you imported to reach them gives 94. Both are honest and they are answers to different questions, so a reader who recounts and gets one more has not found a defect — they have used the other convention. Stated because someone did exactly that from outside, and a number published without its predicate can only be agreed with or disagreed with, never checked. **Every figure in this paragraph moved by one when `assumptions` landed, and nothing went red for two rounds** -- the guard that compares them to the artifact only runs when a built tree exists, so it is silent in every session that does not build one. A check conditioned on an artifact is not a check that runs.
+**And the count is of SUBMODULES: the root package is not one of them.** Walking `arbiter_engine` for what it contains gives 96; adding the package you imported to reach them gives 97. Both are honest and they are answers to different questions, so a reader who recounts and gets one more has not found a defect — they have used the other convention. Stated because someone did exactly that from outside, and a number published without its predicate can only be agreed with or disagreed with, never checked. **Every figure in this paragraph moved by TWO when the reference producer landed, and by one when `assumptions` did, and that earlier move went unnoticed for two rounds** -- the guard that compares them to the artifact only runs when a built tree exists, so it is silent in every session that does not build one. A check conditioned on an artifact is not a check that runs.
 
 Honest boundaries, stated because you would otherwise find them yourself:
 

{arbiter_engine-0.2.6 → arbiter_engine-0.2.8}/README.md

@@ -476,7 +476,7 @@ The engine is open. The knowledge and the operations are not.
 
 ## Status
 
-**v0.2.** 95 Python files, 93 modules importing on the declared dependencies alone, 15 supported
+**v0.2.** 98 Python files, 96 modules importing on the declared dependencies alone, 15 supported
 names — **counted in this repository**, which is the package you are holding.
 
 That basis is stated because it is easy to get wrong in a way nobody notices. The build adds one
@@ -485,7 +485,7 @@ are holding — and this line published the smaller figure until 2026-08-12, whe
 falsify it with `find . -name '*.py' | wc -l`. A checkable false claim, in the Status section of a
 project whose subject is checkable claims. Count the artifact, never an earlier stage of it.
 
-The import figure carries the same hazard one layer down, and it depends on what you have installed. Sweeping the package where `scipy` happens to be present imports 94; on the declared dependencies alone it is the 93 above, because `propagation.lp_confidence` is the one module that needs `scipy` and it is a deep path outside the supported surface. Count the artifact **in the state the reader will have it**, not in the state the person measuring happens to be standing in — this line quoted the with-`scipy` figure until 2026-08-12, which no reader installing normally could reproduce.
+The import figure carries the same hazard one layer down, and it depends on what you have installed. Sweeping the package where `scipy` happens to be present imports 97; on the declared dependencies alone it is the 96 above, because `propagation.lp_confidence` is the one module that needs `scipy` and it is a deep path outside the supported surface. Count the artifact **in the state the reader will have it**, not in the state the person measuring happens to be standing in — this line quoted the with-`scipy` figure until 2026-08-12, which no reader installing normally could reproduce.
 
 **The supported-name count went stale in exactly the way this section warns about.** It read
 three short for the release that added `SqliteObservationHistory`, `SessionCalendar` and
@@ -502,7 +502,7 @@ committed by the paragraph. The figures are described here now rather than quote
 rule the changelog states for its own errata: a correction that reproduces the string it corrects
 is that string to a checker.
 
-**And the count is of SUBMODULES: the root package is not one of them.** Walking `arbiter_engine` for what it contains gives 93; adding the package you imported to reach them gives 94. Both are honest and they are answers to different questions, so a reader who recounts and gets one more has not found a defect — they have used the other convention. Stated because someone did exactly that from outside, and a number published without its predicate can only be agreed with or disagreed with, never checked. **Every figure in this paragraph moved by one when `assumptions` landed, and nothing went red for two rounds** -- the guard that compares them to the artifact only runs when a built tree exists, so it is silent in every session that does not build one. A check conditioned on an artifact is not a check that runs.
+**And the count is of SUBMODULES: the root package is not one of them.** Walking `arbiter_engine` for what it contains gives 96; adding the package you imported to reach them gives 97. Both are honest and they are answers to different questions, so a reader who recounts and gets one more has not found a defect — they have used the other convention. Stated because someone did exactly that from outside, and a number published without its predicate can only be agreed with or disagreed with, never checked. **Every figure in this paragraph moved by TWO when the reference producer landed, and by one when `assumptions` did, and that earlier move went unnoticed for two rounds** -- the guard that compares them to the artifact only runs when a built tree exists, so it is silent in every session that does not build one. A check conditioned on an artifact is not a check that runs.
 
 Honest boundaries, stated because you would otherwise find them yourself:
 

{arbiter_engine-0.2.6 → arbiter_engine-0.2.8}/STANCE.md

@@ -79,6 +79,28 @@ declaration.
 its own stated spread. It does not order producers, recommend one, or carry a
 reputation between sessions.
 
+## The reference producer, which gets none of the above either
+
+The package ships one: `arbiter_engine.producers.baseline_learner`, a
+damped-trend exponential smoother. It exists because the engine's own baseline
+is a **random walk** — it predicts the last value and widens with the horizon —
+and a random walk is the right floor and a poor opponent. Anything that notices
+a series is going somewhere beats it, so *beats the baseline* against a random
+walk alone says almost nothing.
+
+**It is a producer, not a feature.** It reads a session through
+`reading_history()`, the accessor this engine tells every reader to use, and
+files ordinary records through `ingest_forecasts`. It imports no checker, is
+handed no privilege an outside forecaster would be refused, and is scored by
+exactly the rules above — including `not_a_producers_submission` if its records
+carry a `source`. A baseline with access the competition lacks is not a
+baseline, and the suite asserts its import surface as well as its score.
+
+**It refuses rather than guessing.** A series shorter than its minimum gets no
+forecast, and one whose points are not ordered in time is refused rather than
+sorted — re-ordering a series nobody gave you that way is how a producer comes
+to score well on data it invented.
+
 ## Why the engine sets its own records aside
 
 The engine is a producer too. `rollout` files what it projected; every

{arbiter_engine-0.2.6 → arbiter_engine-0.2.8}/arbiter_engine/api.py

@@ -754,7 +754,16 @@ _FEEDERS_ON_THE_SUPPORTED_SURFACE = (
 )
 
 
-def _proposed_transitions(session: EngineSession) -> Dict[str, Any]:
+def _replay_proposal(session: EngineSession, proposal: Any,
+                     surprises: Any) -> Dict[str, Any]:
+    """One proposal's replay, or the refusal that stands in for it."""
+    from arbiter_engine.surprises import replay_proposal
+
+    return replay_proposal(session, proposal, surprises)
+
+
+def _proposed_transitions(session: EngineSession,
+                          surprises: Any = None) -> Dict[str, Any]:
     """Fitted gains, their support, and any that contradict a declaration.
 
     Reported from `model_describe` rather than from a verb of its
@@ -767,6 +776,32 @@ def _proposed_transitions(session: EngineSession) -> Dict[str, Any]:
     author's claim about the system, and an engine that silently replaced it
     with a fitted number would leave nobody able to say what the model
     asserts -- the file would no longer be the model.
+
+    RULED 2026-09-25, A VERTICAL MAY WRITE ONE DOWN; THIS ENGINE
+    STILL MAY NOT. The phase plan asked for an `adopt <proposal_id>` verb,
+    and this package had refused one twice -- here and in
+    `causal/discovery.py`. The ruling separates the two things that question
+    runs together. What is refused above is an ENGINE acting on its own
+    measurement: a process handed a file to read, rewriting it, on a number
+    nobody asked it for. What is now permitted is a tool DOWNSTREAM of this
+    one, whose own author maintains the file, invoked by a person who typed
+    the proposal's name, writing the number with a basis beside it saying
+    where it came from. The file still says what the model asserts. It now
+    says the author chose to assert a fitted number, and says so in the file.
+
+    THE DISTANCE IS THE WHOLE OF THE RULING, AND NONE OF IT IS HERE: a
+    separate distribution, a separate command, a named proposal, a recorded
+    basis, and a gate that refuses a number which would have caught nothing.
+    Take any one of those away and what is left is the thing refused above.
+
+    So nothing in this package opens a model for writing, and the shipped
+    suite holds that by RUNNING this surface -- the replay included, which
+    substitutes a proposal to measure it -- and comparing the model file's
+    bytes, size and modification time afterwards. Not by reading this source
+    for a `write` call, which is a check on text about a claim concerning
+    behaviour. The first downstream writer is `bmc-sensor-audit adopt`, which
+    writes a fitted `gain` and its `gain_basis` into the supplemental file that
+    vertical's operator already maintains by hand.
     """
     from arbiter_engine.twin.transition_learner import (
         MINIMUM_PAIRED_SAMPLES, learn_transitions,
@@ -816,7 +851,14 @@ def _proposed_transitions(session: EngineSession) -> Dict[str, Any]:
              # author's behalf is the one thing this surface does not do.
              "residual_autocorrelation": p.residual_autocorrelation,
              "gain_sigma_assumes_independent_residuals":
-                 p.standard_error_assumes_independence}
+                 p.standard_error_assumes_independence,
+             # WOULD ADOPTING THIS HAVE CAUGHT MORE. A proposal is a
+             # number somebody has to decide about, and `n` and `r_squared`
+             # answer how well it fits the data it was fitted on, which is not
+             # the same question. Without a corpus this is a REFUSAL carrying
+             # its reason, never a zero: a proposal nobody could test is not a
+             # proposal that failed.
+             "replay": _replay_proposal(session, p, surprises)}
             for p in proposals],
         "not_fitted": [
             {"edge": r.location, "reason": r.reason, "detail": r.detail}
@@ -1051,7 +1093,8 @@ def _transition_coverage(model, session: Optional[EngineSession] = None
     }
 
 
-def model_describe(session: EngineSession) -> Envelope:
+def model_describe(session: EngineSession,
+                   surprises: Any = None) -> Envelope:
     """What domain is loaded: entity types, indicators, declared axioms.
 
     This is the grounding tool. An agent calls it before reasoning so it
@@ -1150,7 +1193,7 @@ def model_describe(session: EngineSession) -> Envelope:
         # ones the author declared. Proposals: nothing here has changed the
         # model, and a `gain: estimate` transition projects no value until a
         # number is adopted into the YAML.
-        "proposed_transitions": _proposed_transitions(session),
+        "proposed_transitions": _proposed_transitions(session, surprises),
         # the list, mounted where a MODEL fact belongs. `check` has
         # carried it since it was added; this verb, whose whole question is
         # *did my model load the way I wrote it*, did not -- so a reader
@@ -2461,6 +2504,61 @@ def entail(session: EngineSession, adopt: bool = False) -> Envelope:
     return _WithPayload(envelope, payload)
 
 
+def hypothesize(session: EngineSession, entity_id: str,
+                report_above: Optional[float] = None) -> Envelope:
+    """What could explain a finding on `entity_id`, ranked, with what to read next.
+
+    THE INVERSE OF `gaps`. That verb says what the MODEL does not declare; this
+    says what the WORLD might be doing given what it does — the same question
+    turned around, and the one an operator has after a finding names an entity
+    that is wrong.
+
+    Each candidate is a DECLARED causal ancestor, scored by the same inference
+    `infer` runs, and carries the reading that would discriminate it and the
+    declared action that could test it. Nothing here searches for a cause
+    outside the graph: an engine proposing causes nobody declared would be doing
+    the inference this project removed from `role:` and from flow direction.
+
+    **It is only as good as the evidence severity.** With every breach at
+    `warning` and no `causal.evidence_severity:` declared, no finding counts as
+    evidence, every posterior sits at its prior, and the ranking is an ordering
+    of priors rather than of explanations. Measured on the shipped substation
+    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. 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)
+
+    if session.model is None:
+        return unavailable_envelope("no domain model loaded")
+    try:
+        sub, ranked = _hypothesize(session, entity_id, report_above=report_above)
+    except Exception as exc:  # noqa: BLE001 - see `_raised`
+        sub, ranked = _raised("inference", exc, {"candidates": 0}), []
+
+    envelope = Envelope(
+        checked=CheckedSummary(invariants=0, entities=len(session.entities)),
+        findings=list(sub.findings), questions=[_q(q) for q in sub.questions])
+    payload = envelope.to_dict()
+    payload["hypothesis"] = sub.to_dict()
+    payload["hypothesis"]["candidates"] = ranked
+    return _WithPayload(envelope, payload)
+
+
 def infer(session: EngineSession, target: str,
           do: Optional[Dict[str, int]] = None,
           report_above: Optional[float] = None) -> Envelope:
@@ -2500,6 +2598,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.6 → arbiter_engine-0.2.8}/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.6 → arbiter_engine-0.2.8}/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.