hypgraph 0.8.5__tar.gz → 0.8.7__tar.gz

{hypgraph-0.8.5 → hypgraph-0.8.7}/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## Unreleased
 
+## 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`,
+  `$cost_per_change$`, `<claim_id>`, and a bare name shaped like a figure standing where the figure belongs ("a
+  p-value steps_k_p", "before costs of cum_rule_before"). Over every BC-250 challenge record (1,535 claims) 13 were
+  written this way and reviewers checked three of them, one with a note listing the numbers the claim left out. A
+  name beside its value passes: "17.13 % (oos_return)", "oos_return = 0.17", "a mean_diff of 1.7"; a column named
+  `steps_k` is a name, not a slot.
+- **A claim that is a question says nothing.** A statement ending in a question mark is refused as `STATEMENT_EMPTY`.
+  On a BC-250 run a seat wrote the question's own text as a claim superseding its right answer, and the reviewer
+  checked it, so the question settled on a question. A question followed by its answer passes as before.
+
 ## 0.8.5 — 2026-11-06: fewer false refusals
 
 - A date a source writes as an ordinal is in the source: "the 14th of June 1887" accounts for "14 June 1887". It was refused as an unbound number, and a seat ended up with a claim saying the bridge opened "on a date".

{hypgraph-0.8.5 → hypgraph-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.8.5
+Version: 0.8.7
 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.5 → hypgraph-0.8.7}/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.5 (2026-11-06)
+## Status at 0.8.7 (2026-11-08)
 
 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.5 → hypgraph-0.8.7}/docs/RELEASE-READINESS.md

@@ -261,6 +261,22 @@ was taken from a changelog without being checked against the code.*
 > with two or more of them when the exporting and verifying processes hashed strings differently. The list now follows
 > the order the hypotheses were added. #109 is merged with green CI. Released as 0.8.3.
 
+> **After 0.8.5 (2026-11-07).** Checks only, no change to the bundle format: two ways a claim said nothing and got
+> checked on the BC-250 sweeps. A statement ending in a question mark is refused (a seat wrote the question's own text
+> as a claim superseding its right answer, and the question settled on a question); a figure's name standing where the
+> figure belongs is refused (`$mean_tutored`, `steps_k_p`, `cum_rule_before` — 13 such claims over 1,535, three of
+> 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.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.5 → hypgraph-0.8.7}/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.5"
+__version__ = "0.8.7"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.8.5 → hypgraph-0.8.7}/src/hypgraph/checks.py

@@ -4,7 +4,7 @@ and each refusal does the arithmetic the writer skipped, then offers the honest
 
   code                          refused when
   ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
-  STATEMENT_EMPTY               the statement says nothing ("Placeholder.", "TBD", one word)
+  STATEMENT_EMPTY               the statement says nothing ("Placeholder.", "TBD", one word, a question)
   SCOPE_MISSING                 a finding or exclusion doesn't say under which conditions it holds
   EVIDENCE_MISSING              nothing supports it
   MEASUREMENT_MALFORMED         a measurement doesn't name its result and field
@@ -1599,8 +1599,14 @@ def _exclusion(s: Snap, stmt: str, kind: str, support: list[str], bound: list) -
 
 
 _ORDINAL = re.compile(r"\b(\d+)(?:st|nd|rd|th)\b", re.I)
-# a value not filled in: a template's {date}, or a variable's name where its value belongs ("accuracy = A_easy_acc")
-_SLOT = re.compile(r"\{\s*[A-Za-z_][\w.]*\s*\}|=\s*[A-Za-z]+_[A-Za-z0-9_]*\b(?!\s*\()")
+# a value not filled in: a template's {date} / $mean_tutored / $cost_per_change$ / <claim_id>, a variable's name where
+# its value belongs ("accuracy = A_easy_acc"), or a figure's name standing in the sentence as if it were the figure
+# ("a p-value steps_k_p", "before costs of cum_rule_before"; BC-250 sweeps 2026-11-05..07: 13 of 1,535 claims, three
+# of them checked by reviewers whose notes listed the numbers the claim left out). A name beside its value is not a
+# slot: "17.13 % (oos_return)", "oos_return = 0.17", "a mean_diff of 1.7"; a column named steps_k is a name
+_FIGURE_SUFFIX = r"p|pvalue|p_value|diff|before|after|return|mean|value|low|high|ci|count|ratio|gain|sd|se"
+_SLOT = re.compile(r"\{\s*[A-Za-z_][\w.]*\s*\}|\$\{?[A-Za-z_]\w*\}?\$?|<[A-Za-z_]\w*>|=\s*[A-Za-z]+_[A-Za-z0-9_]*\b(?!\s*\()"
+                   rf"|(?<![\w`(])[A-Za-z]+(?:_[A-Za-z]+)*_(?:{_FIGURE_SUFFIX})\b(?!\s*(?:[=:≈(\d]|is|was|of|at)\s*[-+−]?\d)(?!\s*\))")
 _PLACEHOLDER = re.compile(r"^\W*(?:(?:placeholder|tbd|todo|tba|n/?a|none|wip|xxx|test|claim|statement|pending|"
                           r"to be (?:determined|confirmed|added)|lorem ipsum)\W*)+$", re.I)
 
@@ -1793,6 +1799,12 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
         # refused the date, a seat wrote "opened on {date}", and a later version "on a date" was checked as the answer
         problems.append(Problem("STATEMENT_EMPTY", f"the statement has an unfilled slot ({slot.group(0).strip()}): "
                                 "write the value itself", words=[slot.group(0).strip()]))
+    if stmt.rstrip().rstrip("'\")").endswith("?"):
+        # a seat wrote the question's own text as the claim, as superseding its right answer, and the reviewer checked
+        # it ("the test failures confirm the claim"): the right answer was buried under a question mark (BC-250,
+        # 2026-11-07, E1). A question followed by its answer still ends in a sentence, and passes
+        problems.append(Problem("STATEMENT_EMPTY", "the statement is a question: write the answer to it — what was "
+                                "found, on what, and what it came to"))
     if kind == "convention" and L.HEDGE.search(stmt):
         problems.append(Problem("CONVENTION_HEDGED", "a convention states agreed notation; a hedged interpretation "
                                 "(could / suggests / consistent with) is a finding or a lead"))

{hypgraph-0.8.5 → hypgraph-0.8.7}/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}

{hypgraph-0.8.5 → hypgraph-0.8.7}/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"))

hypgraph-0.8.7/tests/test_consistent_load.py

@@ -0,0 +1,76 @@
+"""A snapshot is loaded at one moment. Two Graphs on one file — hypswarm's scheduler and the MCP server a person's
+agent works through, one process, two threads — used to tear a load: each table was its own implicit read, so a node
+and its edge committed between the ``nodes`` read and the ``edges`` read left the edge naming a node the snapshot
+didn't hold; the edge was skipped and its mark advanced past it, and that Graph never saw the edge again until a
+rebuild. On Ubuntu CI the scheduler then found "no live claim" on a question every other Graph showed answered,
+reworked the order, and asked the external seat to count again (2026-11-05 to 11-08)."""
+import sqlite3
+import threading
+import time
+
+from hypgraph import Graph
+
+
+class _Interleave:
+    """A connection whose first read of ``edges`` lets a hook run first — the window the other Graph writes into."""
+
+    def __init__(self, con: sqlite3.Connection, hook) -> None:
+        object.__setattr__(self, "_con", con)
+        object.__setattr__(self, "_hook", hook)
+        object.__setattr__(self, "_fired", False)
+
+    def execute(self, sql, *args):
+        if "FROM edges" in sql and not self._fired:
+            object.__setattr__(self, "_fired", True)
+            self._hook()
+        return self._con.execute(sql, *args)
+
+    def __getattr__(self, name):
+        return getattr(self._con, name)
+
+    def __setattr__(self, name, value):
+        setattr(self._con, name, value)
+
+
+def _produced(g: Graph, run: str) -> list[str]:
+    return sorted(e["dst"] for e in g.snapshot().out.get(run, []) if e["rel"] == "produced")
+
+
+def test_a_row_committed_during_a_load_is_seen_by_the_next_one(tmp_path):
+    db = tmp_path / "g.hypgraph"
+    a, b = Graph(db), Graph(db)
+    inv = a.create(author="importer", type="investigation",
+                   fields={"title": "Two readers", "objective": "A load must not lose what lands beside it."})["id"]
+    run = a.create(author="importer", type="run", inv=inv, fields={"kind": "agent", "state": "succeeded"})["id"]
+    a.snapshot()                                                    # a holds a snapshot: the next load is a delta
+    b.create(author="importer", type="source", inv=inv, fields={"citation": "Someone, a paper, 2026."})
+    #                                                               # b changed the file: a's next snapshot() loads
+
+    def write_from_b():
+        b.create(author="ana", type="result", inv=inv, links=[{"rel": "produced", "from": run}],
+                 fields={"summary": "Counted the items.", "kind": "computed", "values": {"m": {"k": 40, "n": 90}}})
+
+    t = threading.Thread(target=write_from_b)
+
+    def hook():
+        t.start()                                                   # b commits a result and its edge — now, if the
+        time.sleep(0.3)                                             # load lets it; after the load, if it doesn't
+
+    a._local.con = _Interleave(a._connect(), hook)
+    a.snapshot()                                                    # the load with the window in it
+    t.join(timeout=15)
+    assert not t.is_alive()
+    assert not a._connect().in_transaction                         # the load left no transaction open
+    assert _produced(a, run) == _produced(Graph(db), run) != []    # a sees the edge a rebuild sees
+
+
+def test_a_load_inside_a_write_joins_its_transaction(tmp_path):
+    g = Graph(tmp_path / "g.hypgraph")
+    con = g._connect()
+    con.execute("BEGIN IMMEDIATE")
+    try:
+        g._invalidate()
+        g.snapshot()                                                # a rebuild inside an open transaction
+        assert con.in_transaction                                   # still ours: the load did not commit it
+    finally:
+        con.execute("ROLLBACK")

{hypgraph-0.8.5 → hypgraph-0.8.7}/tests/test_measure_questions.py

@@ -20,9 +20,9 @@ def _g(profile: str, asks: str | None = "measure"):
     return g, inv, q
 
 
-def _measured(g, inv, q):
+def _measured(g, inv, q, part_of=True):
     run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "count", "state": "succeeded", "config": {"source": "print('count')"}},
-                   links=[{"rel": "part_of", "to": q}])["id"]
+                   links=[{"rel": "part_of", "to": q}] if part_of else [])["id"]
     rs = g.create(author="w", type="result", inv=inv, fields={"summary": "A is right on 781 of 1000 items.",
                   "values": {"a_correct": {"k": 781, "n": 1000}}, "outcome": "positive"},
                   links=[{"rel": "produced", "from": run}])["id"]
@@ -45,6 +45,20 @@ def test_a_scientific_measure_question_needs_no_hypothesis():
     assert g.stage(q)["complete"]
 
 
+def test_a_question_answered_through_its_result_needs_no_part_of_link_on_the_run():
+    """hypswarm's register_run writes run → result → claim and links only the claim to the question. The run gate
+    read "no run executes an experiment on Q1" on a question whose result and claim were both met, so the harness
+    issued a `run` order every round beside the review and the seats filed 11 claims on 3 questions without
+    settling one (BC-250 S3, 2026-11-07). The run behind a result on the question is a run on the question."""
+    g, inv, q = _g("scientific@2")
+    c = _measured(g, inv, q, part_of=False)
+    st = g.stage(q)
+    assert st["stage"] == "reviewed", [(gt["gate"], gt["met"], gt["why"]) for gt in st["gates"]]
+    assert next(gt for gt in st["gates"] if gt["gate"] == "run_registered")["met"]
+    g.review(author="critic", target=c, verdict="checked", method="Recounted the file.", notes="781 of 1000.")
+    assert g.stage(q)["complete"]
+
+
 def test_without_asks_every_gate_still_applies():
     g, inv, q = _g("scientific@2", asks=None)
     assert g.stage(q)["stage"] == "conjectured"

hypgraph-0.8.7/tests/test_statement_is_a_question.py

@@ -0,0 +1,51 @@
+"""A claim that is a question says nothing. On a BC-250 run of the bug-fix challenge (2026-11-07) a seat wrote the
+question's own text as a claim, "Which tests in test_semver.py fail on the original semver.py, and what causes each
+failure?", linked it as superseding its right answer, and the reviewer checked it: the question settled on a question."""
+from __future__ import annotations
+
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+QUESTION = "Which tests in test_semver.py fail on the original semver.py, and what causes each failure?"
+ANSWER = ("test_minor_numeric, test_prerelease_before_release and test_newest fail on the original semver.py, because "
+          "compare() orders numeric parts as strings.")
+
+
+def _record():
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    inv = g.create(author="a", type="investigation", fields={
+        "title": "semver", "objective": "Fix the version comparison.", "profile": "software@2"})["id"]
+    q = g.create(author="a", type="question", inv=inv, fields={"text": QUESTION})["id"]
+    run = g.create(author="a", type="run", inv=inv, fields={"kind": "agent", "name": "pytest on the original",
+                                                            "state": "succeeded", "config": {"source": "pytest -q _base"}})["id"]
+    res = g.create(author="a", type="result", inv=inv, fields={
+        "summary": "Three of six tests fail on the original.", "values": {"tests_passed": {"k": 3, "n": 6}}},
+        links=[{"rel": "produced", "from": run}])["id"]
+    return g, inv, q, res
+
+
+def _claim(g, inv, q, res, statement):
+    return g.create(author="a", type="claim", inv=inv, fields={
+        "statement": statement, "scope": "The six tests in test_semver.py, run on the kept copy of semver.py."},
+        links=[{"rel": "answers", "to": q}, {"rel": "supports", "from": res, "why": "the run shows which tests fail"}])
+
+
+@pytest.mark.parametrize("statement", [QUESTION, "Does the original fail test_newest?", "Which tests fail? "])
+def test_a_claim_that_is_a_question_is_refused(statement):
+    g, inv, q, res = _record()
+    with pytest.raises(GraphError, match="STATEMENT_EMPTY") as e:
+        _claim(g, inv, q, res, statement)
+    assert "is a question" in str(e.value)
+
+
+@pytest.mark.parametrize("statement", [ANSWER, f"Which tests fail on the original semver.py? {ANSWER}", "Why? Because compare() orders numeric parts as strings."])
+def test_an_answer_passes_with_or_without_the_question_before_it(statement):
+    g, inv, q, res = _record()
+    assert _claim(g, inv, q, res, statement)["id"]
+
+
+def test_the_refusal_names_what_to_write():
+    g, inv, q, res = _record()
+    with pytest.raises(GraphError, match="write the answer to it"):
+        _claim(g, inv, q, res, QUESTION)

{hypgraph-0.8.5 → hypgraph-0.8.7}/tests/test_statement_slots.py

@@ -43,18 +43,40 @@ def test_a_number_the_source_doesnt_have_stays_unbound():
     "The footbridge opened to the public on { date }.",
     "Model A easy accuracy = A_easy_acc on the items.",
     "The strategy with fast window {fast_window} returned the most.",
+    # BC-250 sweeps (2026-11-06/07): $name, $name$, and a figure's name in the sentence — three of these were checked
+    "The mean gain from test 1 to test 2 was $mean_tutored for tutored pupils.",
+    "The rule returned less after paying $cost_per_change$ per position change.",
+    "The rule returned ${cost} after costs.",
+    "The only outcome that differed is steps_k, with a p-value steps_k_p.",
+    "The rule achieved a cumulative return before costs of cum_rule_before.",
+    "Over the calls of the fixed sample_three, duplicate_count returned a repeated winner.",
+    "The claim <claim_id> answers the question about the footbridge.",
 ])
 def test_a_statement_with_a_slot_is_refused(statement):
     g, inv, src = _record()
-    with pytest.raises(GraphError, match="STATEMENT_EMPTY"):
+    with pytest.raises(GraphError, match="STATEMENT_EMPTY") as e:
         _claim(g, inv, src, statement)
+    assert "unfilled slot" in str(e.value)
 
 
 @pytest.mark.parametrize("statement", [
     "The minutes set the option `retry = max_tries` for the footbridge.",
     "The function returned `{date}` for the footbridge.",
     "The footbridge opened in the summer, as the minutes say.",
+    "The minutes say steps_k differs between the arms for the footbridge.",
 ])
 def test_code_and_plain_sentences_are_not_slots(statement):
     g, inv, src = _record()
     assert _claim(g, inv, src, statement)["id"]
+
+
+@pytest.mark.parametrize("statement", [
+    "The out-of-sample return is 17.13 % (oos_return), versus -17.08 % (buy_and_hold_return).",
+    "oos_return = 0.1713 and bh_return: -0.1708 out of sample.",
+    "A mean_diff of 1.7 points, with a p_value of 0.33.",
+    "The bridge cost $4,210 according to the minutes.",
+    "steps_k_p is 0.012 and steps_k_diff was -0.8 steps.",
+])
+def test_a_name_beside_its_figure_is_not_a_slot(statement):
+    from hypgraph.checks import _SLOT
+    assert not _SLOT.search(statement), _SLOT.search(statement)