hypgraph 0.4.0__tar.gz → 0.4.1__tar.gz

{hypgraph-0.4.0 → hypgraph-0.4.1}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.1 — 2026-10-25
+
+Three rules the hypswarm examples exposed, each with a test:
+- A claim's numbers that appear in a cited source's passage, citation or title are accounted for (a knowledge claim
+  "signed on 24 October 1648" citing the passage that says so is no longer `UNBOUND_NUMBER`).
+- A rework's predicates count evidence written since the **first** order of its chain (`coord.chain_root`): a
+  `tests_pass` met by the instrument's re-run under the original order stays met under the rework.
+- `PASS_WITHOUT_INSTRUMENT_RUN` accepts a claim resting on the author's result when a live lab run `replicates`
+  the run that produced it and the re-run's result is positive (`profiles._instrument_backed`).
+
 ## 0.4.0 — 2026-10-25: the coordination layer
 
 Held until the harmony study had exercised every path (pilots 1–4, a 142-run confirmatory, two follow-up rounds). Governance profiles, token-bound authors, work orders with predicates, order text that carries the target, instrument reproduction, replayable refusals.

{hypgraph-0.4.0 → hypgraph-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.4.0
+Version: 0.4.1
 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.4.0 → hypgraph-0.4.1}/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.4.0"
+__version__ = "0.4.1"
 
 from .bundle import verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.4.0 → hypgraph-0.4.1}/src/hypgraph/checks.py

@@ -385,6 +385,9 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
     plain, stat = derived_numbers(bound)
     allowed = plain + [v for v, *_ in numbers(scope)] + \
         [float(c) for c in (invb.get("constants") or []) if isinstance(c, (int, float))]
+    for src in support:                              # a cited source's own text accounts for the numbers in it
+        sb = s.nodes[src]["body"] if s.nodes[src]["type"] == "source" else {}
+        allowed += [v for v, *_ in numbers(" ".join(str(sb.get(k) or "") for k in ("passage", "citation", "title")))]
     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)]

{hypgraph-0.4.0 → hypgraph-0.4.1}/src/hypgraph/cli.py

@@ -515,7 +515,7 @@ def build_parser() -> argparse.ArgumentParser:
     s.add_argument("file", help="the markdown file ('-' for stdin)")
     s.add_argument("--inv", default="", help="the investigation it reports on (default: inferred)")
     s.add_argument("--strict", action="store_true", help="warnings (e.g. unsourced numbers) fail too")
-    s = cmd("bound", cmd_bound, "what k of n actually supports: the 95% bounds behind any 'never'")
+    s = cmd("bound", cmd_bound, "what k of n actually supports: the 95%% bounds behind any 'never'")
     s.add_argument("k", type=int, help="how many times it happened")
     s.add_argument("n", type=int, help="how many trials")
     s.add_argument("--exposure", type=float, default=0, help="how many uses / users / units it will apply to")

{hypgraph-0.4.0 → hypgraph-0.4.1}/src/hypgraph/coord.py

@@ -235,10 +235,20 @@ def _claims_on(s: D.Snap, t: str) -> list[str]:
     return list(dict.fromkeys(out))
 
 
+def chain_root(s: D.Snap, oid: str) -> str:
+    """The first order of a rework chain (follows ``supersedes``); an order that replaced nothing is its own root."""
+    seen = [oid]
+    while True:
+        older = [e["dst"] for e in s.out.get(seen[-1], []) if e["rel"] == "supersedes"]
+        if not older or older[0] in seen:
+            return seen[-1]
+        seen.append(older[0])
+
+
 def _eval(g: "Graph", s: D.Snap, oid: str, pred: dict, text: str) -> dict:
     p = pred.get("p", "")
     t = target_of(s, oid)
-    at = s.nodes[oid]["created_at"]
+    at = s.nodes[chain_root(s, oid)]["created_at"]     # a rework keeps what its earlier attempts wrote
     res = {"p": p, "met": False, "evidence": [], "why": ""}
     if p in profiles.PRED_DESC:
         return res | profiles.evaluate(p, s, oid, t, at, s.nodes[oid]["body"].get("assignee", ""), s.nodes[oid]["inv"])

{hypgraph-0.4.0 → hypgraph-0.4.1}/src/hypgraph/profiles.py

@@ -200,6 +200,23 @@ def _lab_positive(s: D.Snap, rid: str) -> bool:
     return bool(r) and s.nodes[r]["body"].get("kind") == "lab" and s.nodes[rid]["body"].get("outcome") == "positive"
 
 
+def _instrument_backed(s: D.Snap, rid: str) -> bool:
+    """A result is instrument-backed when it comes from a lab run, or when a lab run replicates the run that
+    produced it and that re-run's own result is positive (the instrument re-executed the author's code)."""
+    if _lab_positive(s, rid):
+        return True
+    r = _producing_run(s, rid)
+    if not r:
+        return False
+    for lab in (e["src"] for e in s.inn.get(r, []) if e["rel"] == "replicates"):
+        if s.nodes[lab]["body"].get("kind") != "lab" or not _live(s, lab):
+            continue
+        if any(e["rel"] == "produced" and s.nodes[e["dst"]]["body"].get("outcome") == "positive"
+               for e in s.out.get(lab, [])):
+            return True
+    return False
+
+
 def _bearing(s: D.Snap, t: str, ntype: str) -> list[str]:
     """Nodes of a type linked to the target by any relation, either way."""
     out = [e["src"] for e in s.inn.get(t, []) if s.nodes[e["src"]]["type"] == ntype]
@@ -287,11 +304,12 @@ def claim_issues(s: D.Snap, inv: str, body: dict, support: list, pending: list)
                                "or gap — an incumbent without a bound is a solution, not an optimum",
                                fix="bind a result with bound or gap, or say 'best found'"))
     if "pass_needs_instrument" in p.validators and L.asserted(_PASSES, stmt):
-        ok = any(_lab_positive(s, r) for r in results)
+        ok = any(_instrument_backed(s, r) for r in results)
         if not ok:
             out.append(Problem("PASS_WITHOUT_INSTRUMENT_RUN", "'passes' is asserted, but no supporting result comes "
                                "from an instrument-recorded run — tests must be run by the instrument, not reported",
-                               fix="register_run with the test command as code; the instrument's re-run is the evidence"))
+                               fix="register_run with the test command as code; the instrument's re-run is the evidence — write the "
+                "claim once the re-run has landed (the order's reply names it)"))
     if "claim_needs_source" in p.validators and kind in ("finding", "exclusion"):
         cites = any(rel == "cites" and s.nodes.get(b, {}).get("type") == "source" for a, rel, b in pending) or \
             any(_cites_source(s, x) for x in support if x in s.nodes and s.nodes[x]["type"] in ("claim", "result"))

hypgraph-0.4.1/tests/test_profiles_041.py

@@ -0,0 +1,69 @@
+"""0.4.1: three rules the hypswarm examples exposed. A cited source accounts for the numbers in its passage; a
+rework keeps the evidence its chain already produced; a claim of passing tests may rest on the author's result once
+the instrument's re-run of that run is positive."""
+import time
+
+from hypgraph import Graph, GraphError, Policy
+from hypgraph.coord import chain_root
+
+import pytest
+
+H = "harness"
+
+
+def _g(profile):
+    g = Graph(policy=Policy(reviewers={"critic"}, extra_reserved={H}, instrument="lab"))
+    inv = g.create(author=H, type="investigation", fields={"title": "A profiled investigation.",
+                                                          "objective": "See the 0.4.1 rules hold.", "profile": profile})["id"]
+    q = g.create(author=H, type="question", inv=inv, code="Q1", fields={"text": "When was it signed?"})["id"]
+    return g, inv, q
+
+
+def test_a_cited_source_accounts_for_its_numbers():
+    g, inv, q = _g("knowledge@1")
+    src = g.create(author="r", type="source", inv=inv, fields={"citation": "Britannica, 'Peace of Westphalia'.",
+                                                              "url": "https://www.britannica.com/event/Peace-of-Westphalia",
+                                                              "passage": "the treaties were signed on October 24, 1648"})["id"]
+    c = g.create(author="r", type="claim", inv=inv, fields={"statement": "The Peace of Westphalia was signed on 24 October 1648.",
+                                                           "scope": "The treaties of Osnabrück and Münster.", "kind": "finding"},
+                 links=[{"rel": "answers", "to": q}, {"rel": "cites", "to": src}])
+    assert c["code"].startswith("CL")
+    with pytest.raises(GraphError, match="UNBOUND_NUMBER"):                      # a number the source does not contain
+        g.create(author="r", type="claim", inv=inv, fields={"statement": "It was signed by 109 delegations.",
+                                                           "scope": "The treaties of Osnabrück and Münster.", "kind": "finding"},
+                 links=[{"rel": "answers", "to": q}, {"rel": "cites", "to": src}])
+
+
+def test_a_rework_keeps_its_chains_evidence():
+    g, inv, q = _g("software@1")
+    o = g.issue_work(author=H, inv=inv, target=q, assignee="tester", objective="Run the tests.")
+    time.sleep(1.1)
+    r = g.create(author="tester", type="run", inv=inv, fields={"kind": "agent", "name": "pytest", "state": "succeeded"})
+    rs = g.create(author="tester", type="result", inv=inv, fields={"summary": "Ran pytest.", "values": {"passed": {"k": 3, "n": 3}}, "outcome": "positive"},
+                  links=[{"rel": "produced", "from": r["id"]}])
+    lab = g.create(author="lab", type="run", inv=inv, fields={"kind": "lab", "name": "re-run of pytest", "state": "succeeded"},
+                   links=[{"rel": "replicates", "to": r["id"], "data": {"differs": "same_code"}}])
+    g.create(author="lab", type="result", inv=inv, fields={"summary": "Re-executed: 1 of 1 values confirmed.", "values": {"passed": {"k": 3, "n": 3}}, "outcome": "positive"},
+             links=[{"rel": "produced", "from": lab["id"]}])
+    first = {p["p"]: p["met"] for p in g.check_work(o["order"])["predicates"]}
+    assert first == {"tests_pass": True, "claim_made": False}
+    rw = g.rework(author=H, order=o["order"], missing="no live claim on Q1 since the order was issued")
+    assert chain_root(g.snapshot(), rw["order"]) == o["order"]
+    second = {p["p"]: p["met"] for p in g.check_work(rw["order"])["predicates"]}
+    assert second["tests_pass"] is True                                          # 0.4.0 lost it: evidence predated the rework
+    # (c) the claim of passing may now rest on the author's result: the instrument replicated its run positively
+    c = g.create(author="tester", type="claim", inv=inv, fields={"statement": "The importer passes all 3 of 3 tests in test_importer.py.",
+                                                                "scope": "test_importer.py at this commit."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs["id"]}])
+    assert c["code"].startswith("CL")
+    assert all(p["met"] for p in g.check_work(rw["order"])["predicates"])
+
+
+def test_passing_still_needs_the_instrument():
+    g, inv, q = _g("software@1")
+    r = g.create(author="tester", type="run", inv=inv, fields={"kind": "agent", "name": "pytest", "state": "succeeded"})
+    rs = g.create(author="tester", type="result", inv=inv, fields={"summary": "Ran pytest.", "values": {"passed": {"k": 3, "n": 3}}, "outcome": "positive"},
+                  links=[{"rel": "produced", "from": r["id"]}])
+    with pytest.raises(GraphError, match="PASS_WITHOUT_INSTRUMENT_RUN"):
+        g.create(author="tester", type="claim", inv=inv, fields={"statement": "The importer passes all 3 of 3 tests.", "scope": "test_importer.py at this commit."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs["id"]}])