hypgraph 0.8.6__tar.gz → 0.8.8__tar.gz

{hypgraph-0.8.6 → hypgraph-0.8.8}/CHANGELOG.md

@@ -2,6 +2,81 @@
 
 ## Unreleased
 
+## 0.8.8 — 2026-11-15: the record tells a liar who keeps at it from one who moved on
+
+No change to the bundle format. One check closes a back door (a link is checked like the claim's create); the
+rest were found by small showcase experiments on gpt-oss-20b (BC-250), where a paid critic argued against an
+honest researcher and a writer drafted launch headlines from test counts. The conduct log now counts a lie said
+again beside a figure it denies as a repeat, and a new false figure each time as persisting (`conduct()` gains
+`replaced_false`); the bound a refusal suggests is accepted; "flawlessly" and "without a single error" are
+absolutes. Each was checked by replaying the experiments' logs, with no model calls: on 0.8.7 the replays
+reproduce the runs exactly.
+
+- **A link that adds support to a claim is checked like the claim's create.** Claim checks ran when a claim was
+  created or revised, never when a later `link` added to what it rests on. So any check that reads the support
+  (a source that says the opposite, a count against an absolute, a profile's source rules) could be stepped round:
+  write the claim on harmless support, then link the rest. In a HypSwarm swarm on gpt-oss-20b (BC-250, 2026-11-10)
+  an inconclusive answer was created on a result, and its `cites` link to an unreferenced source was added 53 s
+  later. It was reviewed checked. A non-curator's link that changes a claim's support now runs `checks.claim_issues`
+  and the profile's claim checks with and without the link. The link is refused only for problems it brings; one the
+  claim already had doesn't block an unrelated link. The refusal is logged as `op=link` on the claim. Replayed over
+  270 swarm records on the released profiles, 0 of 5,079 later links would be refused.
+- **A lie said again beside a figure it denies or compares is a repeat.** A count contradiction stored every number
+  in the refused statement as part of the lie, including a denied or compared one ("40 km, **not 38 km**", "31 km,
+  since the true total **exceeds 30 km**"). `refusals.carried` never counts those as asserted, so the same sentence
+  said again was logged as moving off it, not as a repeat. The refusal now stores only the figures the statement
+  asserts (`checks.asserted_figures`, one pattern for both sides), and `carried` reads refusals logged before this
+  through the refused statement. Found in the spot-the-bad-actor showcase (gpt-oss-20b, BC-250, 2026-11-15): replaying
+  its 20 record-arm disputes, one paid critic goes from 0 repeats and 5 moves off to 3 repeats, still saying it at
+  the end. No other party's conduct changes.
+- **A new false figure each time reads as persisting, not moving off.** An author refused six times with a different
+  figure each time (31, 32, 33 km ...) had every refusal logged as moving off the last one, and `conduct()` summed it
+  up as "the author did not say it again". `conduct()` now counts `replaced_false`: claims shown false whose author's
+  last word on them was a move into another claim the record also showed false. It is a subset of `moved_off`, so
+  existing fields keep their meaning. The sentence says it ("did not say the same claim again, but replaced a
+  contradicted claim with another the record also contradicted 5 times, and never corrected it"). Derived on read
+  from the log, so existing records read the new way. Found in the spot-the-bad-actor showcase (gpt-oss-20b, BC-250,
+  2026-11-15), where a tie-breaker reading the record acquitted such a critic. Replaying its 20 record-arm disputes:
+  6 of 10 paid critics get a replacement count, no honest party does, and no verdict of the record rule changes.
+- **The honest wording a refusal suggests is accepted.** `ABSOLUTE_UNDERPOWERED` suggests "no occurrences in 8
+  trials (95% upper bound 31%)", and `bound()` prints "at most 31%". The record then refused that figure as unbound,
+  for two reasons. Statistical figures had to be written to a decimal place, and for k = n the printed bound
+  (1 − lower bound) wasn't among the derived numbers at all. A percentage the statement itself labels as a bound
+  ("upper bound", "at most", "no more than" …) now matches a bound count's 95% bounds, or their complements, as
+  printed. The match is by position, so a labelled bound vouches for nothing else in the sentence. Unlabelled
+  figures keep the decimal rule. `check_text` does the same. Found in the say-no-more-than-the-data showcase
+  (gpt-oss-20b, BC-250, 2026-11-15). Replaying its 82 headline attempts, 11 that were refused are now accepted, all
+  of them correct bounds for their counts, and no other outcome changes.
+- **"Flawlessly" and "without a single error" are absolutes.** They say of how things went what "every" says of
+  how many, and they weren't in `language.ABSOLUTE`. So "Real-world files parsed flawlessly" on 76 of 77 went in,
+  while "every real-world file parsed" on the same count was refused. Added: flawless(ly), without (a single / any /
+  one) error / failure / fault / crash / exception / bug / mistake / glitch / hitch, and error- / failure- / fault- /
+  crash- / bug-free. These words describe the manner of their subject, so they cover every one of it only when the
+  subject does: "nearly all files parsed flawlessly", "72 of 73 parsed without error" and "flawlessly, only a handful
+  slipped" stay true and still go in. Found in the say-no-more-than-the-data showcase (gpt-oss-20b, BC-250,
+  2026-11-15). Replaying its 82 headline attempts, the 4 false drafts that used these words are refused, and no
+  other outcome changes. None of the 2,646 HypSwarm records on hand has a claim using them.
+
+## 0.8.7 — 2026-11-08: a snapshot is loaded at one moment
+
+No change to the bundle format or the checks: one read fix and one scope fix, both found running HypSwarm.
+
+- **A snapshot is loaded at one moment.** The tables behind a snapshot were each read in their own implicit
+  transaction, so a second Graph on the same file could commit a node and its edge between the `nodes` read and
+  the `edges` read; the edge then named a node the snapshot didn't hold, was skipped, and its mark was advanced
+  past it — that Graph never saw the edge again until a rebuild. hypswarm's scheduler and the MCP server an
+  external seat works through share a file this way (one process, two threads); on Ubuntu CI the scheduler found
+  "no live claim" on a question every other Graph showed answered, reworked the order, and asked the seat to count
+  again, which the record refused as a restatement (2026-11-05 to 11-08, never on Windows). A rebuild, a delta
+  (with its retraction check) and the row load now run inside one read transaction; a load inside a write's own
+  transaction joins it. Reproduced deterministically before the fix (`tests/test_consistent_load.py`).
+- **The run behind a result on a question is a run on the question.** A question's scope collected results through
+  its claims (`derived_from`, `supports`) but runs only through an experiment's `executes` or a `part_of` link. A
+  harness that registers run → result → claim and links only the claim to the question left the run gate reading
+  "no run executes an experiment on Q1" with the result and the claim both met; the harness issued a `run` order
+  every round beside the review, and on one BC-250 run the seats filed 11 claims on 3 questions without settling
+  one (S3, 2026-11-07). The scope now adds the runs that `produced` its results.
+
 ## 0.8.6 — 2026-11-07: a placeholder is not a statement
 
 - **A figure's name is not the figure.** The slot check (`STATEMENT_EMPTY`) now refuses `$mean_tutored`,

{hypgraph-0.8.6 → hypgraph-0.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.8.6
+Version: 0.8.8
 Summary: The evidence layer for AI research agents: a hash-chained research record that checks every claim as it is written and derives how well each is known.
 Project-URL: Homepage, https://hypgraph.com
 Project-URL: Documentation, https://hypgraph.com/engineers/

{hypgraph-0.8.6 → hypgraph-0.8.8}/docs/PLAN.md

@@ -109,7 +109,7 @@ claim's derived standing.
 Multi-writer sync between graphs (bundles cover sharing), authentication (the host's job; the HTTP server binds to
 loopback and is read-only unless started with `--writable`), and a hosted service.
 
-## Status at 0.8.6 (2026-11-07)
+## Status at 0.8.8 (2026-11-15)
 
 All seven phases are done: the library, bundles, the server and UI, the MCP server, the website, Pegasus running on
 the package, and releases to PyPI from tags with trusted publishing. What came after the plan, by release, is in

{hypgraph-0.8.6 → hypgraph-0.8.8}/docs/RELEASE-READINESS.md

@@ -268,6 +268,27 @@ was taken from a changelog without being checked against the code.*
 > them checked), while a name beside its value passes. Tests: `tests/test_statement_slots.py`,
 > `tests/test_statement_is_a_question.py`. #115 and #116 are merged with green CI. Released as 0.8.6.
 
+> **After 0.8.7 (2026-11-15).** No change to the bundle format. A link that adds support to a claim runs the
+> claim checks, so a check can't be stepped round by linking after the create (#121). Four fixes from showcase
+> experiments on gpt-oss-20b (BC-250): a refusal no longer stores a denied or compared figure as part of the lie,
+> so the same sentence said again is a repeat (#122); `conduct()` counts `replaced_false`, a false claim left only
+> for another false one, and says so (#123); a percentage a statement labels as a bound matches a count's 95%
+> bounds as printed, so the honest wording `ABSOLUTE_UNDERPOWERED` and `bound()` suggest is accepted (#124);
+> "flawlessly", "without a single error" and "-free" are absolutes unless their subject is a part (#125).
+> Replaying the experiments' logs: one paid critic's repeats 0 → 3, six get a replacement count, no honest party
+> changes; 11 correct bounds now accepted and 4 false headlines now refused, nothing else moves. Tests:
+> `tests/test_contradictions.py`, `tests/test_bound_wording.py`, `tests/test_implied_absolutes.py`,
+> `tests/test_link_rechecks.py`. #121–#125 are merged with green CI. Released as 0.8.8.
+
+> **After 0.8.6 (2026-11-08).** No change to the bundle format or the checks. A snapshot's tables were each read in
+> their own implicit transaction, so a second Graph on the same file could commit a node and its edge between the
+> `nodes` read and the `edges` read; the edge was skipped and its mark advanced past it, lost to that Graph until a
+> rebuild (HypSwarm's scheduler beside its MCP server, on Ubuntu CI). Rebuild, delta and row load now run inside one
+> read transaction; `tests/test_consistent_load.py` reproduces the loss on the old code. And a question's scope
+> counts the runs that `produced` its results, so a harness that links only the claim to the question no longer sees
+> "no run executes an experiment" with the result and claim both met. #118 and #119 are merged with green CI.
+> Released as 0.8.7.
+
 > **After 0.8.4 (2026-11-06).** Checks only, no change to the bundle format: false refusals found running HypSwarm on a
 > small local model. A report that denies significance is warned, not refused; a named p-value carries the test; a word
 > and a figure are a statement, and an unfilled slot isn't; an ordinal in a source accounts for the number. Tests:

{hypgraph-0.8.6 → hypgraph-0.8.8}/src/hypgraph/__init__.py

@@ -16,7 +16,7 @@ Standing is derived on every read, never stored; every write is an event in a SH
 their numbers; reviews pin versions; independence is counted, not assumed. See https://hypgraph.com.
 """
 
-__version__ = "0.8.6"
+__version__ = "0.8.8"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.8.6 → hypgraph-0.8.8}/src/hypgraph/checks.py

@@ -187,7 +187,7 @@ def derived_numbers(bound: list[tuple[dict, dict]]) -> tuple[list[float], list[f
             k, n = a
             lo, hi = stats.rate_bounds(k, n)
             plain += [k / n, 1 - k / n, n - k]
-            stat += [lo, hi]
+            stat += rate_bound_values(k, n)
             arms.append(a)
         p = _primary(rv)
         if p is not None:
@@ -212,6 +212,40 @@ def _matches_stat(printed: tuple, candidates: list[float]) -> bool:
     return printed[1] >= 1 and _matches(printed, candidates)
 
 
+def rate_bound_values(k: int, n: int) -> list[float]:
+    """A count's 95% bounds and their complements: the bound on the rate seen, and on the opposite rate ("12 of 12
+    read correctly" bounds failures at 1 - lower bound, which is what the refusals and ``bound()`` print)."""
+    lo, hi = stats.rate_bounds(k, n)
+    return [lo, hi, 1 - lo, 1 - hi]
+
+
+# a figure the statement itself says is a bound: "(95% upper bound 31%)", "at most 19% of the time", "no more than 4%"
+_LABELLED_BOUND = re.compile(r"\b(?:(?:upper|lower)\s+(?:95\s*%\s+)?(?:confidence\s+)?(?:bound|limit)|at\s+most|"
+                             r"at\s+least|no\s+more\s+than|no\s+less\s+than|bounded\s+(?:at|by))"
+                             r"(?:\s+(?:of|is|at|was))?\s*[:=≈]?\s*(?:about\s+|around\s+|roughly\s+|~\s*)?"
+                             r"(\d[\d,]*(?:\.\d+)?\s*%)", re.I)
+
+
+def split_bounds(text: str) -> tuple[str, list[tuple]]:
+    """(the text with each labelled bound's figure blanked, those figures as ``numbers`` gives them). Split by
+    position, so a figure the statement labels as a bound vouches for nothing else that happens to print the same
+    ("rose 31% ... (upper bound 31%)")."""
+    out, labelled, i = [], [], 0
+    for m in _LABELLED_BOUND.finditer(text or ""):
+        out.append(text[i:m.start(1)] + " ")
+        labelled += numbers(m.group(1))
+        i = m.end(1)
+    out.append((text or "")[i:])
+    return "".join(out), labelled
+
+
+def _matches_bound(printed: tuple, bounds: list[float]) -> bool:
+    """A percentage the statement labels as a bound may match a count's 95% bound as printed, whole numbers too: the
+    refusals and ``bound()`` print them that way ("95% upper bound 31%"), and a labelled bound borrows nothing.
+    The decimal rule stays for unlabelled figures."""
+    return printed[2] and _matches(printed, bounds)
+
+
 def _bound(s: Snap, meas: list, stmt: str = "", words: bool = True) -> tuple[list[tuple[dict, dict]], list[Problem]]:
     """Measurements that check out against their results, and problems with the rest. With ``stmt``, the claim's
     statement: what a key says it counted must be said by the measurement's name or by the statement. ``words``
@@ -1143,8 +1177,24 @@ def _fmt(v: float) -> str:
 
 def _subject_numbers(stmt: str, k: int, n: int) -> list[float]:
     """The figures a contradicted statement asserts, other than the count itself: what it would have to change to be
-    corrected (refusals.conduct reads them to tell a correction from the same claim said again)."""
-    return [v for v, *_ in numbers(stmt) if v not in (0, k, n)]
+    corrected (refusals.conduct reads them to tell a correction from the same claim said again). Only figures it
+    asserts (``asserted_figures``): in "the shortest route is 40 km, not 38 km" or "... is 31 km, since the true total
+    exceeds 30 km" the lie is 40 or 31. Storing 38 or 30 with it meant the same sentence said again never counted as a
+    repeat, because a repeat must assert every stored figure and refusals.carried never counts a denied or compared
+    one as asserted. A statement whose every figure is denied or compared keeps them all."""
+    said = asserted_figures(stmt) or {v for v, *_ in numbers(stmt)}
+    return [v for v, *_ in numbers(stmt) if v not in (0, k, n) and v in said]
+
+
+# a figure the statement doesn't assert but denies or compares against: "not 38", "isn't 38", "instead of 38",
+# "than 26", "exceeds 30", "above 90" (refusals.carried reads statements through the same pattern)
+NOT_ASSERTED = re.compile(r"(?:\b(?:not|never|than|above|below|over|under|beyond|exceed(?:s|ing|ed)?|except|"
+                          r"instead\s+of)|n't)\s+(?:about\s+|around\s+|roughly\s+)?\$?\d[\d,]*(?:\.\d+)?", re.I)
+
+
+def asserted_figures(stmt: str) -> set[float]:
+    """The figures a statement asserts: every number it gives, less those it denies or compares against."""
+    return {v for v, *_ in numbers(NOT_ASSERTED.sub(" ", stmt or ""))}
 
 
 # a word a statement denies: "not kilograms", "doesn't apply", "never reached" (the one or two words after it)
@@ -1825,7 +1875,11 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
         allowed += [v for v, *_ in numbers(_ORDINAL.sub(r"\1", said))]   # "the 14th of June" accounts for "14 June"
     if _CONVENTIONS.search(clean):                   # "95% interval", "α 0.05", "80% power" are conventions
         allowed += [95.0, 99.0, 90.0, 80.0, 0.05, 0.01]
-    loose = [p for p in numbers(clean) if not _matches(p, allowed) and not _matches_stat(p, stat)]
+    rest, labelled = split_bounds(clean)              # "(95% upper bound 31%)": a bound the statement names as one
+    bounds = [b for _m, rv in bound if (a := _arm(rv)) for b in rate_bound_values(*a)]
+    loose = [p for p in numbers(rest) if not _matches(p, allowed) and not _matches_stat(p, stat)]
+    loose += [p for p in labelled if not _matches(p, allowed) and not _matches_stat(p, stat)
+              and not _matches_bound(p, bounds)]
     if loose:
         problems.append(Problem("UNBOUND_NUMBER", "numbers in the statement that no bound measurement, the scope or the "
                                 "investigation's constants account for: " + ", ".join(p[3] for p in loose[:8])

{hypgraph-0.8.6 → hypgraph-0.8.8}/src/hypgraph/graph.py

@@ -394,15 +394,32 @@ class Graph:
 
     def _rebuild(self, con) -> D.Snap:
         s = D.Snap(0, self.policy)
-        retracted = {r[0] for r in con.execute("SELECT edge FROM retractions")}
-        self._load_rows(con, s, retracted)
-        s.seq = max(self._head_seq(con), s.seq)
+        own_txn = not con.in_transaction            # retractions, rows and the head seq read at one moment
+        if own_txn:
+            con.execute("BEGIN")
+        try:
+            retracted = {r[0] for r in con.execute("SELECT edge FROM retractions")}
+            self._load_rows(con, s, retracted)
+            s.seq = max(self._head_seq(con), s.seq)
+        finally:
+            if own_txn:
+                con.execute("COMMIT")
         return s
 
     def _load_rows(self, con, s: D.Snap, retracted: set, *, shared: bool = False) -> set:
         """Add every row newer than s.marks to s (all of it for a fresh Snap) and return the ids of the nodes those
         rows touched. ``shared``: s's per-node lists still belong to an older snapshot too, so a list is copied the
-        first time this load appends to it (readers of the old snapshot never see it change) and appended to after."""
+        first time this load appends to it (readers of the old snapshot never see it change) and appended to after.
+
+        The tables are read inside one read transaction, so they are read at one moment. Each SELECT used to be its
+        own implicit transaction: a second connection (another Graph on the file — hypswarm's scheduler and the MCP
+        server a person's agent works through, in one process on two threads) could commit a claim and its
+        ``answers`` edge after this load had read ``nodes`` and before it read ``edges``. The edge then named a node
+        the snapshot didn't hold yet, was skipped, and its mark was advanced past it, so this Graph never saw the
+        edge again until a rebuild: the question stood answered in every other Graph while the scheduler's
+        ``check_work`` found "no live claim", reworked the order, and the seat was asked to count again (hypswarm's
+        ``test_an_external_seat_works_orders_over_mcp`` on Ubuntu, 2026-11-05 to 11-08). A load already inside a
+        transaction (a write that reads) joins it."""
         touched: set = set()
         owned: set = set()
 
@@ -413,6 +430,9 @@ class Graph:
             else:
                 table[key].append(item)
 
+        own_txn = not con.in_transaction
+        if own_txn:
+            con.execute("BEGIN")
         con.row_factory = sqlite3.Row
         try:
             m = s.marks
@@ -462,6 +482,8 @@ class Graph:
             s.leases = {k: v for k, v in s.leases.items() if v["expires"] > t}
         finally:
             con.row_factory = None
+            if own_txn:
+                con.execute("COMMIT")
         return touched
 
     def _delta(self, con, old: D.Snap) -> Optional[D.Snap]:
@@ -469,21 +491,29 @@ class Graph:
         are shallow copies (C speed), and a per-node list is copied only when this load appends to it — a write
         costs what it touched, not the size of the graph. Derived standing carries over for every node the write
         can't have affected (derive.affected_by). None (rebuild instead) when an edge was retracted: retractions
-        remove, they don't append."""
-        if con.execute("SELECT 1 FROM events WHERE seq > ? AND kind = 'retract' LIMIT 1", (old.seq,)).fetchone():
-            return None
-        s = D.Snap(old.seq, self.policy)
-        s.nodes = dict(old.nodes)
-        s.edges = dict(old.edges)
-        s.out = defaultdict(list, old.out)
-        s.inn = defaultdict(list, old.inn)
-        s.withdrawn = dict(old.withdrawn)
-        s.leases = dict(old.leases)
-        s.versions = defaultdict(list, old.versions)
-        s.events = list(old.events)
-        s.marks = dict(old.marks)
-        s._sigs = old._sigs                       # keyed by body: still right for every node not revised
-        touched = self._load_rows(con, s, set(), shared=True)
+        remove, they don't append. The retraction check and the load are one read transaction: a retraction
+        committed between them would otherwise be loaded as a live edge and its event's seq passed over."""
+        own_txn = not con.in_transaction
+        if own_txn:
+            con.execute("BEGIN")
+        try:
+            if con.execute("SELECT 1 FROM events WHERE seq > ? AND kind = 'retract' LIMIT 1", (old.seq,)).fetchone():
+                return None
+            s = D.Snap(old.seq, self.policy)
+            s.nodes = dict(old.nodes)
+            s.edges = dict(old.edges)
+            s.out = defaultdict(list, old.out)
+            s.inn = defaultdict(list, old.inn)
+            s.withdrawn = dict(old.withdrawn)
+            s.leases = dict(old.leases)
+            s.versions = defaultdict(list, old.versions)
+            s.events = list(old.events)
+            s.marks = dict(old.marks)
+            s._sigs = old._sigs                   # keyed by body: still right for every node not revised
+            touched = self._load_rows(con, s, set(), shared=True)
+        finally:
+            if own_txn:
+                con.execute("COMMIT")
         if old._state and touched:
             stale = D.affected_by(s, touched)
             s._state = {k: v for k, v in old._state.items() if k not in stale}
@@ -1131,6 +1161,8 @@ class Graph:
                             raise self._sealed(hidden, f"a link that rests {s.nodes[x]['code'] or x} on sealed work")
                 if src in s.nodes:
                     self._fixed_guard(s, author, src)
+                if author not in self.policy.curators:
+                    self._recheck_linked_claims(s, author, (src, rel, dst))
                 eid = self._transaction(lambda con: self._insert_edge(con, s, src, rel, dst, data or {}, why, author,
                                                                       self.clock()))
             except GraphError as e:
@@ -1151,6 +1183,35 @@ class Graph:
                 out["fixes_refusals"] = fixed
         return out
 
+    def _recheck_linked_claims(self, s: D.Snap, author: str, edge: tuple[str, str, str]) -> None:
+        """A link that adds to what a claim rests on is checked as the claim's create would have been: otherwise any
+        check that reads the support is stepped round by writing the claim first and linking the rest after. Only
+        the problems the link brings refuse it; one the claim already had (the record changed around it) doesn't."""
+        for x in dict.fromkeys(edge[::2]):
+            n = s.nodes.get(x)
+            if not n or n["type"] != "claim" or x in s.withdrawn:
+                continue
+            before = self._support_ids(s, x, [])
+            after = self._support_ids(s, x, [edge])
+            if after == before:
+                continue
+            body, inv = n["body"], n["inv"]
+            # the claim's own links stand in for the pending links its create was checked with
+            own = [(e["src"], e["rel"], e["dst"]) for e in s.out.get(x, []) + s.inn.get(x, [])]
+
+            def issues(support: list[str], pending: list[tuple[str, str, str]]) -> list:
+                return list(claim_issues(s, body, support, inv)) + list(profiles.claim_issues(s, inv, body, support,
+                                                                                              pending))
+            had = {(p.code, p.message) for p in issues(before, own)}
+            new = [p for p in issues(after, own + [edge]) if (p.code, p.message) not in had]
+            if new:
+                found = [p.to_dict() for p in new]
+                refusals.record_refusal(self, author=author, op="link", inv=inv, node=x, body=body, problems=found,
+                                        support=after)
+                c = n["code"] or x
+                raise GraphError(f"link refused: {c} would rest on it, and {c} with it is refused:\n- "
+                                 + "\n- ".join(p.text() for p in new), found)
+
     def retract(self, *, author: str, edge: int, why: str) -> dict:
         if len(str(why or "").strip()) < 10:
             raise GraphError("why: say why this link no longer holds")

{hypgraph-0.8.6 → hypgraph-0.8.8}/src/hypgraph/language.py

@@ -29,6 +29,10 @@ ABSOLUTE = re.compile(
     r"\b(never|always|all|every|none|nothing|no one|nobody|impossible|cannot|can't|proves?|proven|proof|certainly|"
     r"certain|guaranteed?|guarantees|eliminat(?:es|ed|ing)|entirely|completely|totally|universally|invariably|"
     r"consistently|without exception|perfect(?:ly)?|solves?|solved|definitively|conclusively|undeniably|"
+    # an absolute with no "all" in it: "files parsed flawlessly" on 62 of 63, "without a single error" on 52 of 55
+    # (both accepted in the say-no-more-than-the-data showcase, 2026-11-15)
+    r"flawless(?:ly)?|without\s+(?:a\s+single\s+|any\s+|one\s+)?(?:error|failure|fault|crash|exception|bug|"
+    r"mistake|glitch|hitch)e?s?|(?:error|failure|fault|crash|bug)-free|"
     r"zero(?!-)"
     # "no route is longer than 26 km": a universal negative comparison, the same claim as "nothing is longer"; only
     # where "no" opens its clause ("routes that visit no town twice" is not one); "no route is 26 km or longer" and
@@ -131,10 +135,31 @@ def asserted(pattern: re.Pattern, text: str) -> list[str]:
             continue
         if m.group(0).lower() in ("entirely", "wholly", "completely") and _INTERVAL_SIDE.match(text, m.start()):
             continue
+        if _MANNER.fullmatch(m.group(0)) and (_PART_SUBJECT.search(_clause_before(text, m.start()))
+                                              or _EXCEPTIONS.search(text)):
+            continue
         out.append(m.group(0).lower())
     return list(dict.fromkeys(out))
 
 
+# an absolute said of how things went, not of how many: "parsed flawlessly", "without a single error", "error-free".
+# It covers every one of its subject only when the subject does: "nearly all files parsed flawlessly", "72 of 73 files
+# parsed without error" and "flawlessly, only a handful slipped" say so of a part (all four were in the
+# say-no-more-than-the-data showcase, 2026-11-15, and true of their counts)
+_MANNER = re.compile(r"flawless(?:ly)?|without\s.*|\w+-free", re.I | re.S)
+_PART_SUBJECT = re.compile(r"\b(?:(?:almost|nearly|virtually|practically)\s+(?:all|every)|most|mostly|majority|many|"
+                           r"some|several|all\s+but|\d[\d,]*\s+(?:of|out\s+of)\s+\d)", re.I)
+_EXCEPTIONS = re.compile(r"\b(?:except(?:\s+for)?|all\s+but|but\s+(?:one|two|a\s+few)|apart\s+from|save\s+for|"
+                         r"other\s+than)\b|\b(?:only|just)\s+(?:a\s+)?(?:few|handful|couple|one|\d+)\b[^.;]*?\b"
+                         r"(?:slipped|failed|fell|broke|crashed|errored|missed|stumbled|faltered|tripped)\b", re.I)
+
+
+def _clause_before(text: str, start: int) -> str:
+    head = text[:start]
+    s0 = max((m.end() for m in _SENTENCE_END.finditer(head)), default=0)
+    return head[max((m.end() for m in _CLAUSE.finditer(head, s0)), default=s0):]
+
+
 def denied(pattern: re.Pattern, text: str) -> list[str]:
     """The matches a sentence negates: "not significantly", "no significant difference"."""
     return [w for w in found(pattern, text) if w not in asserted(pattern, text)]

{hypgraph-0.8.6 → hypgraph-0.8.8}/src/hypgraph/refusals.py

@@ -125,17 +125,15 @@ def _contradicted(detail: str) -> list[dict]:
 
 
 _CLAUSE = re.compile(r"[;!?]|\.(?!\d)")       # a full stop inside a number (3.5) ends no clause
-_NOT_ASSERTED = re.compile(r"\b(?:not|than|above|below|over|under|beyond|exceed(?:s|ing)?|except)\s+"
-                           r"(?:about\s+|around\s+)?\d[\d,]*(?:\.\d+)?", re.I)
 
 
-def carried(problems: list[dict], statement: str, atoms: list | None = None) -> bool:
+def carried(problems: list[dict], statement: str, atoms: list | None = None, was: str = "") -> bool:
     """Does ``statement`` say again what these contradiction problems showed false? A count contradiction is
     carried when one clause holds every figure it named (the '=…' words) again AND still asserts an extreme or an
     absolute about them ("the highest value is 93", "nothing beats 93"): mentioning the old figure in a correction
     ("1 of 82 routes is shorter than 26 km") is not saying it again. A source contradiction is carried when the
     statement still denies or doubts the same word, or still says the unit the source ruled out. A typed atom shown
-    false is carried when ``atoms`` (the new write's) asserts it again."""
+    false is carried when ``atoms`` (the new write's) asserts it again. ``was`` is the refused statement."""
     from . import assertions, checks
     keys = {assertions.key(a) for a in atoms or []}
     denied = checks.denied_words(statement or "")
@@ -150,11 +148,15 @@ def carried(problems: list[dict], statement: str, atoms: list | None = None) ->
         if p.get("code") == "ASSERTION_CONTRADICTED" and {w[5:] for w in words if w.startswith("atom:")} & keys:
             return True
         figs = [float(w[1:]) for w in words if w.startswith("=") and w[1:].replace(".", "", 1).isdigit()]
+        # only the figures the refused statement asserted: refusals logged before 0.8.8 also stored the ones it denied
+        # or compared against ("40 km, not 38 km" gave =40 and =38), so that sentence said again never read as a repeat
+        if was and (said := checks.asserted_figures(was)):
+            figs = [f for f in figs if any(abs(f - s) < 1e-9 for s in said)] or figs
         if p.get("code") != "COUNT_CONTRADICTS" or not figs:
             continue
         for c in clauses:
             # a figure the clause negates or compares ("20 km, not 26 km", "greater than 130") isn't asserted
-            nums = [v for v, *_ in checks.numbers(_NOT_ASSERTED.sub(" ", c))]
+            nums = list(checks.asserted_figures(c))
             # nor is an extreme the clause denies ("the highest value is not 130") or a count's own domain ("a count
             # of every route finds 1 of 74 shorter"): both used to be logged as the lie said again
             if all(any(abs(x - f) < 1e-9 for x in nums) for f in figs) and checks.claimed_extremes(c):
@@ -181,7 +183,7 @@ def _note_reassertion(g: "Graph", *, author: str, inv: str, node: str, op: str,
     con = g._connect()
     since = (datetime.fromisoformat(g.clock()) - FIX_WINDOW).isoformat(timespec="seconds")
     opened = _open_contradictions(con, author, inv, since, before=refusal)
-    hits = [r[0] for r in opened if carried(_contradicted(r[3]), statement, atoms)]
+    hits = [r[0] for r in opened if carried(_contradicted(r[3]), statement, atoms, was=r[2])]
     dropped = _moved_off(con, opened, hits, node=node, statement=statement, answers=answers)
     if not hits and not dropped:
         return
@@ -282,13 +284,13 @@ def match_fix(g: "Graph", *, author: str, inv: str, node: str, statement: str, o
         hits = [r for r in rows if (op == "revise" and r[1] == node) or _overlap(r[2], statement) >= FIX_OVERLAP
                 or _keys_again(r[3], values) or _same_pair(r[2], pair)]
         # a claim shown false and accepted later saying the same false thing is a re-assertion, not a fix
-        again = [r[0] for r in hits if carried(_contradicted(r[3]), statement, atoms)]
+        again = [r[0] for r in hits if carried(_contradicted(r[3]), statement, atoms, was=r[2])]
         hits = [r[0] for r in hits if r[0] not in again]
         # a contradiction this write is about but neither fixes nor says again: the author moved off it
         opened = [r for r in rows if _contradicted(r[3]) and r[0] not in hits]
         again += [r[0] for r in opened if r[0] not in again and _addresses(r, node=node, statement=statement,
                                                                            answers=answers)
-                  and carried(_contradicted(r[3]), statement, atoms)]
+                  and carried(_contradicted(r[3]), statement, atoms, was=r[2])]
         dropped = _moved_off(con, opened, again, node=node, statement=statement, answers=answers)
         if not hits and not again and not dropped:
             return []
@@ -346,11 +348,13 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
     """Per author: how often the record contradicted a claim of theirs (its own count, or a source they cited, says
     the opposite), how often they then corrected it, and how often they said the same thing again.
     {author: {"shown_false", "by_count", "by_source", "corrected", "reasserted", "open", "still_saying", "moved_off",
-    "ends_false", "sentence"}}. ``shown_false`` is every claim contradicted, ``by_count`` / ``by_source`` how many of
+    "replaced_false", "ends_false", "sentence"}}. ``shown_false`` is every claim contradicted, ``by_count`` / ``by_source`` how many of
     them the record's own count or a cited source contradicted (one claim can be both). A
     re-assertion that was itself refused is not counted as a new time shown false. ``still_saying``: claims shown false
     whose author's last word on them (its last fix, repeat or move away, in log order) says them again;
-    ``moved_off``: claims it last moved away from without a fix; ``ends_false``: the author's last write was itself
+    ``moved_off``: claims it last moved away from without a fix; ``replaced_false``: of those, the ones it moved off
+    only into another claim the record also showed false (31 km refused, then 32 km, then 33 km: persisting with a
+    new figure each time, not moving off); ``ends_false``: the author's last write was itself
     shown false or said a contradicted claim again (a fresh false claim at the end counts, which ``still_saying``,
     being per claim, can't see). ``shown_false`` is not a rate of lying: it adds up two kinds of evidence, and a cited
     source can itself be wrong. Read the parts, and what the author did next, not the total."""
@@ -382,8 +386,12 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
                 r = None
             if r:
                 root[r] = ref
+    # every refusal the record showed false, repeats included: a move off a claim into one of these is no move off
+    contra = {rid for rid, kind, _a, _r, codes, _d in rows
+              if kind == "refused" and set(json.loads(codes or "[]")) & set(CONTRADICTIONS)}
     last: dict[int, str] = {}                       # each claim shown false → its author's last word on it
-    for _id, kind, _a, ref, _c, _d in rows:         # rows come in log order
+    into_false: set[int] = set()                    # … when that last word was a move into another false claim
+    for _id, kind, _a, ref, _c, det in rows:        # rows come in log order
         if kind in ("fixed", "reasserted", "dropped") and ref:
             r, seen = ref, set()
             while r not in shown and r in root and r not in seen:
@@ -391,10 +399,15 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
                 r = root[r]
             if r in shown:
                 last[r] = kind
+                try:
+                    to = json.loads(det or "{}").get("refusal")
+                except Exception:  # noqa: BLE001
+                    to = None
+                (into_false.add if kind == "dropped" and to in contra else into_false.discard)(r)
     out: dict[str, dict] = {}
     for rid, a in shown.items():
         o = out.setdefault(a, {"shown_false": 0, "by_count": 0, "by_source": 0, "by_assertion": 0, "corrected": 0,
-                               "reasserted": 0, "open": 0, "still_saying": 0, "moved_off": 0})
+                               "reasserted": 0, "open": 0, "still_saying": 0, "moved_off": 0, "replaced_false": 0})
         o["shown_false"] += 1
         o["by_count"] += "COUNT_CONTRADICTS" in shown_codes[rid]
         o["by_source"] += "SOURCE_CONTRADICTS" in shown_codes[rid]
@@ -406,6 +419,7 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
         o["open"] += not fixed and not again
         o["still_saying"] += last.get(rid) == "reasserted"
         o["moved_off"] += last.get(rid) == "dropped"
+        o["replaced_false"] += rid in into_false
     # where each author ends: its last write — a refused one, or an accepted one that fixed, repeated or moved off a
     # claim shown false — either was shown false (refused as contradicted) or said a contradicted claim again, or not
     writes: dict[tuple, list] = {}
@@ -432,13 +446,19 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
             + ([f"a typed count showed an assertion of this author's false {t_} time{'s' * (t_ != 1)}"] if t_ else [])
             + ([f"{s_} claim{'s' * (s_ != 1)} of this author's went against a source it cited as support"]
                if s_ else []))
+        x = o["replaced_false"]
         o["sentence"] = (shown + "; "
                          + (f"the author said it again {o['reasserted']} time{'s' * (o['reasserted'] != 1)} after "
-                            "being shown" if o["reasserted"] else "the author did not say it again")
-                         # "never corrected" only beside a repeat: dropping a claim for a different one is no repeat
+                            "being shown" if o["reasserted"] else "the author did not say the same claim again"
+                            if x else "the author did not say it again")
+                         # moving off a false claim only into another false one is persisting, not moving off
+                         + (f"{', and' if o['reasserted'] else ', but'} replaced a contradicted claim with another the "
+                            f"record also contradicted {x} time{'s' * (x != 1)}" if x else "")
+                         # "never corrected" only beside a repeat or a replacement: dropping a false claim for a
+                         # different, unrefuted one is no repeat
                          + (f", and corrected it {o['corrected']} time{'s' * (o['corrected'] != 1)}"
                             if o["corrected"] else ", and never corrected it"
-                            if o["reasserted"] and (o["still_saying"] or o["ends_false"]) else "")
+                            if (o["reasserted"] or x) and (o["still_saying"] or o["ends_false"]) else "")
                          + ("; its last word still says it" if o["still_saying"] else
                             "; its last word was contradicted by the record" if o["ends_false"] else
                             "; its last word no longer says it" if o["reasserted"] else ""))

{hypgraph-0.8.6 → hypgraph-0.8.8}/src/hypgraph/report_check.py

@@ -45,7 +45,7 @@ from typing import TYPE_CHECKING
 from . import derive as D
 from . import language as L
 from . import stats
-from .checks import _matches, _matches_stat, derived_numbers, numbers
+from .checks import _matches, _matches_bound, _matches_stat, derived_numbers, numbers, split_bounds
 
 if TYPE_CHECKING:
     from .graph import Graph
@@ -269,11 +269,12 @@ def check(g: "Graph", text: str, inv: str = "") -> dict:
             if asks:                     # a question, or the question's own words: citations checked, nothing asserted
                 continue
             # numbers
-            for p in numbers(sent):
+            rest, labelled = split_bounds(sent)     # '95% upper bound 31%': a bound the sentence names as one
+            for p, is_bound in [(p, False) for p in numbers(rest)] + [(p, True) for p in labelled]:
                 if _skip_number(p, sent) or re.search(rf"(?<![\w-])[A-Z]{{1,3}}{re.escape(p[3])}(?![\w-])", sent):
                     continue
                 counted["numbers"] += 1
-                if not _matches(p, plain) and not _matches_stat(p, stat):
+                if not _matches(p, plain) and not _matches_stat(p, stat) and not (is_bound and _matches_bound(p, stat)):
                     add(ln, "warning", "REPORT_UNSOURCED_NUMBER", sent,
                         f"{p[3]} isn't in any result, measurement, claim, scope or constant in the record, and doesn't "
                         "follow from them. Bind it to a result, or take it out.")

{hypgraph-0.8.6 → hypgraph-0.8.8}/src/hypgraph/workflow.py

@@ -104,6 +104,11 @@ class Scope:
             res += typed(out(c, "derived_from"), "result")
         res += typed(inn(root, "part_of"), "result") + ([t] if n["type"] == "result" else [])
         self.results = _uniq(res + mine("result"))
+        # a run that produced a result on the question is a run on the question. A harness registers run → result
+        # → claim with no experiment and no part_of link; the run gate then read "no run executes an experiment" on a
+        # measured question whose result and claim were both met, a `run` order went out every round beside the
+        # review, and 11 claims on 3 questions settled nothing (BC-250 S3, 2026-11-07)
+        self.runs = _uniq(self.runs + [r for x in self.results for r in typed(inn(x, "produced"), "run")])
         decs = [d for x in self.claims + self.results + self.hypotheses for d in typed(inn(x, "based_on"), "decision")]
         decs += [t] if n["type"] == "decision" else []
         self.decisions = _uniq(decs + mine("decision"))