hypgraph 0.8.6__tar.gz → 0.8.7__tar.gz

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

@@ -2,6 +2,26 @@
 
 ## 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`,

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

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

@@ -268,6 +268,15 @@ 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.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.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.6"
+__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.6 → 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.6 → 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.6 → 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"