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

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

@@ -34,6 +34,45 @@ useful-looking document and the less trustworthy one.
 
 ## [Unreleased]
 
+## [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.8}/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.8"
 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.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.7 → arbiter_engine-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arbiter-engine
-Version: 0.2.7
+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

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

@@ -2526,7 +2526,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 +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.7 → 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.7 → 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.

{arbiter_engine-0.2.7 → arbiter_engine-0.2.8}/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.8}/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.8}/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.8}/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

{arbiter_engine-0.2.7 → arbiter_engine-0.2.8}/evidence/alpha1_evidence_pack.md

@@ -121,9 +121,9 @@ Detail is in the hypothesis log's Day-7/8/9 entries. A per-day Day-7 fault-watch
 
 ---
 
-## Methodology — the recursive-examination framework 5-tier exercise framework
+## Methodology — recursive-examination 5-tier exercise framework
 
-Alpha-1 work was structured by the recursive-examination framework (Recursive Examination as Engine) framework — a 5-tier session-level exercise discipline that generates L5 surprises by repeatedly stressing substrate rather than auditing it (auditing reveals known unknowns; exercising reveals unknown unknowns):
+Alpha-1 work was structured by the recursive-examination (Recursive Examination as Engine) framework — a 5-tier session-level exercise discipline that generates L5 surprises by repeatedly stressing substrate rather than auditing it (auditing reveals known unknowns; exercising reveals unknown unknowns):
 
 - **T0**: Data-flow probe (every session start; ~60s) — catches silent-fall-through before per-axis work.
 - **T1**: Diagnostic-signature library match — 18 catalogued signatures save ~30-60 min per match.

{arbiter_engine-0.2.7 → arbiter_engine-0.2.8}/evidence/l5_surprise_synthesis.md

@@ -8,7 +8,7 @@
 
 ## What is an L5 surprise?
 
-L5 surprises are observations that the planned probes had not anticipated. The Alpha's the recursive-examination framework 5-tier exercise framework (T0 data-flow probe → T1 signature library → T2 adversarial cycle → T3 diagnostic-iteration loop → T4 cross-pattern leverage → T5 codification) defines its own surface — the questions each tier knows to ask. L5 surprises are observations that fall outside that surface: they emerge from exercising substrate, not auditing it, and they typically arise during T5 (session-end codification) when the operator notices a pattern that the framework's own probes couldn't see.
+L5 surprises are observations that the planned probes had not anticipated. The Alpha's recursive-examination 5-tier exercise framework (T0 data-flow probe → T1 signature library → T2 adversarial cycle → T3 diagnostic-iteration loop → T4 cross-pattern leverage → T5 codification) defines its own surface — the questions each tier knows to ask. L5 surprises are observations that fall outside that surface: they emerge from exercising substrate, not auditing it, and they typically arise during T5 (session-end codification) when the operator notices a pattern that the framework's own probes couldn't see.
 
 Why partners should care: L5 surprises are the substrate's claim to *real* coverage of cascade behavior in production-like AI/ML serving deployments. If the only findings were from planned probes, the substrate would be reporting back to its own designer. Surprises are the unplanned dividend — observations a partner couldn't have anticipated from the system's documentation alone.
 
@@ -134,7 +134,7 @@ For each L5 surprise (Days 1-11 = 16; Day-12 the second evaluation round RUN add
 - **Anticipated by the probe design, before the load generator was built**: 0 of 16.
 - **Anticipated after the triggering fault event**: 2 of 16 — the cumulative-counter self-clear and the MONOTONICITY axiom-family shift were predictable from the prior day's findings.
 
-So the vast majority were genuinely open-world: the substrate produced findings that the planned probes (the recursive-examination framework T0-T5 + Spikes 1-5) did NOT anticipate.
+So the vast majority were genuinely open-world: the substrate produced findings that the planned probes (recursive-examination T0-T5 + Spikes 1-5) did NOT anticipate.
 
 **Detector anchor (replay) — the result that runs the other way.** Every figure above measures what the *designers* foresaw. None of them says anything about what the *detector* caught, and that number is unfavourable: **0 of the 16 Alpha-1 surprises were machine-surfaced at the time.** A human found all sixteen (the replay verdict, not published — see the provenance list at the end of this document).
 
@@ -216,7 +216,7 @@ request. They are not links; the records themselves can be supplied directly:
 
 **Operator working notes, not documents** — pattern codifications held outside the repository. Listed
 because they are where these findings were generalised, not as retrievable sources:
-alpha-recursive-examination (T1 catalog + the recursive-examination framework framework); the methodology notes
+alpha-recursive-examination (T1 catalog + recursive-examination framework); the methodology notes
 (Pattern N 3-branch family + asymmetric-recovery sub-shape); the methodology notes
 (Pattern N load-bearing); the methodology notes (Compression-B 12× yield).
 

{arbiter_engine-0.2.7 → arbiter_engine-0.2.8}/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.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arbiter-engine"
-version = "0.2.7"
+version = "0.2.8"
 description = "A detection engine that reports what it did not check."
 requires-python = ">=3.10"
 license = "Apache-2.0"

{arbiter_engine-0.2.7 → arbiter_engine-0.2.8}/tests/test_a_forecaster_is_judged_by_the_same_eight_axioms.py

@@ -380,7 +380,7 @@ def test_a_declaration_that_names_models_without_expecting_one_counts_nothing():
 
 
 def test_the_kind_filter_is_now_a_live_path():
-    """IT WAS DEFENCE UNTIL, AND THIS TEST SAID SO AND SAID WHY.
+    """IT WAS DEFENCE UNTIL a later change, AND THIS TEST SAID SO AND SAID WHY.
 
     The version here was named `..._is_defence_and_not_a_live_path`, reported
     that no test claimed to exercise the filter, and gave the measurement