hypgraph 0.4.1__tar.gz → 0.4.3__tar.gz

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

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.4.3 — 2026-10-26
+
+Five vocabulary-friction fixes from the HypSwarm discovery study, where 110 of 118 refusals were binding, naming
+and shape errors rather than overclaims — and one correct answer was refused fifteen times.
+- **A named p-value backs "significantly".** A bound field named `p`, `p_value` or `p_<test>` (an exact McNemar
+  `p_exact`), or such a field on a supporting result, satisfies the significance check; below 0.05 the word is
+  accepted, above it `SIGNIFICANCE_NOT_SHOWN` quotes it. The record's own two-proportion test stays the fallback.
+- **A bound measurement's result supports the claim.** A claim written with `measurements` that name a result gets
+  a `supports` edge from that result, so its standing counts the line of support the writer already bound.
+- **A wrong relation names the right one.** `executes can't join run → question … — a run joins a question with
+  part_of, motivated_by; the other way round, a question joins a run with …`.
+- **Enum synonyms** (`schema.SYNONYMS`): `outcome=success` → `positive`, `kind=fact` → `finding`,
+  `state=done` → `succeeded`, and more; the stored value is canonical.
+- **Small integers bind to a value the sentence names.** "produced 0 trades" binds to `oos_trades`,
+  "capacity is 7" to `capacity_total`; an unnamed small integer still binds only to a count.
+
+## 0.4.2 — 2026-10-25
+
+- **A question is not an assertion.** `language.interrogative` / `asserted` return nothing for a sentence that ends
+  with a question mark, and the report check skips the language and number rules on a sentence that asks or that
+  quotes one of the investigation's own questions (citations are still checked). Found in the first real HypSwarm
+  mixed-swarm run: the lead headed a section "Q2 — Is A significantly more accurate than B…?" and lost its report
+  to `REPORT_SIGNIFICANCE_UNBACKED` three times.
+
 ## 0.4.1 — 2026-10-25
 
 Three rules the hypswarm examples exposed, each with a test:

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

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

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

@@ -274,6 +274,29 @@ def _measured_claim(s: Snap, support: list[str]) -> bool:
     return False
 
 
+_PNAME = re.compile(r"^(p|pval|pvalue|p[_-]?val(?:ue)?|p[_-][a-z0-9_]+)$", re.I)
+
+
+def _p_values(s: Snap, bound: list, support: list[str]) -> list[float]:
+    """The p-values behind a claim: a bound value dict's `p`, a bound field *named* p / p_value / p_<test>
+    (an exact McNemar p registered as `p_exact` is a test), and such fields on the results that support it."""
+    ps = [float(rv["p"]) for _m, rv in bound if isinstance(rv.get("p"), (int, float))]
+    for m, rv in bound:
+        key = str(m.get("key") or m.get("name") or "")
+        v = rv.get("value")
+        if _PNAME.match(key) and isinstance(v, (int, float)) and not isinstance(v, bool) and 0 <= v <= 1:
+            ps.append(float(v))
+    for rid in support:
+        n = s.nodes.get(rid)
+        if not n or n["type"] != "result":
+            continue
+        for key, rv in (n["body"].get("values") or {}).items():
+            v = rv.get("value") if isinstance(rv, dict) else rv
+            if _PNAME.match(str(key)) and isinstance(v, (int, float)) and not isinstance(v, bool) and 0 <= v <= 1:
+                ps.append(float(v))
+    return ps
+
+
 def _comparisons(s: Snap, stmt: str, bound: list, support: list[str]) -> list[Problem]:
     out = []
     comp = L.asserted(L.COMPARATIVE, stmt)
@@ -285,11 +308,13 @@ def _comparisons(s: Snap, stmt: str, bound: list, support: list[str]) -> list[Pr
                            "(a k/n or value for both), or a difference with its interval",
                            fix="bind both sides as measurements", words=comp))
     sig = L.asserted(L.SIGNIFICANCE, stmt)
-    bound_p = [float(rv["p"]) for _m, rv in bound if isinstance(rv.get("p"), (int, float))]
+    bound_p = _p_values(s, bound, [])                      # the claim's own measurements
+    support_p = _p_values(s, [], support)                  # a named p on a supporting result: the last resort
     arms = [_arm(rv) for _m, rv in bound if _arm(rv)]
     no_sig = L.denied(L.SIGNIFICANCE, stmt)
     if no_sig and not sig:                      # "not significant": the record checks that too
-        p = min(bound_p) if bound_p else (stats.two_proportions(*arms[0], *arms[1])["p"] if len(arms) >= 2 else None)
+        p = min(bound_p) if bound_p else (stats.two_proportions(*arms[0], *arms[1])["p"] if len(arms) >= 2
+                                          else (min(support_p) if support_p else None))
         if p is not None and p < 0.05:
             out.append(Problem("SIGNIFICANCE_CONTRADICTED",
                                f"the statement denies significance ('{no_sig[0]}'), but the bound evidence is "
@@ -310,10 +335,16 @@ def _comparisons(s: Snap, stmt: str, bound: list, support: list[str]) -> list[Pr
                                    f"{t['diff'] * 100:.1f} points, 95% interval {t['lo'] * 100:.1f} to "
                                    f"{t['hi'] * 100:.1f}, p = {t['p']:.2g} (two-proportion z-test) — not significant "
                                    "at 0.05. Say the difference and that it isn't significant.", words=sig))
+        elif support_p:
+            if min(support_p) > 0.05:
+                out.append(Problem("SIGNIFICANCE_NOT_SHOWN",
+                                   f"'{sig[0]}': the p-value on the supporting result is {min(support_p):.3g}, not below "
+                                   "0.05 — say the difference and that it isn't significant", words=sig))
         else:
             out.append(Problem("SIGNIFICANCE_WITHOUT_TEST",
-                               f"'{sig[0]}' claims a test was passed: bind a result field holding the p-value or "
-                               "interval, or bind both sides as counts (k/n) so the record can test them",
+                               f"'{sig[0]}' claims a test was passed: bind a result field holding the p-value (a field "
+                               "named p, p_value or p_<test>, e.g. p_mcnemar) or an interval, or bind both sides as "
+                               "counts (k/n) so the record can run its own two-proportion test",
                                fix="bind a p-value, or both sides as k/n", words=sig))
     return out
 

{hypgraph-0.4.1 → hypgraph-0.4.3}/src/hypgraph/graph.py

@@ -31,7 +31,7 @@ from . import derive as D
 from . import refusals, store
 from .checks import claim_issues
 from .policy import Policy
-from .schema import REPLICATION, RELS, SAME_TYPE, TYPES, VERDICTS
+from .schema import REPLICATION, RELS, SAME_TYPE, SYNONYMS, TYPES, VERDICTS
 from .store import canon, now
 
 
@@ -69,6 +69,7 @@ def clean_body(ntype: str, body: dict, *, partial_ok: bool = False) -> dict:
             if req and len(v) < (3 if kind == "str" else 10):
                 raise GraphError(f"{k}: say it in a full sentence")
         elif kind.startswith("enum:"):
+            v = SYNONYMS.get((ntype, k), {}).get(str(v).strip().lower().replace(" ", "_").replace("-", "_"), str(v).strip())
             if str(v) not in kind[5:].split("|"):
                 raise GraphError(f"{k} must be one of {kind[5:].replace('|', ', ')}")
             v = str(v)
@@ -406,8 +407,12 @@ class Graph:
         st, dt = s.nodes[src]["type"], s.nodes[dst]["type"]
         srcs, dsts = RELS[rel]
         if st not in srcs or dt not in dsts:
+            joins = [r for r, (a, b) in RELS.items() if st in a and dt in b and r not in SAME_TYPE]
+            back = [r for r, (a, b) in RELS.items() if dt in a and st in b and r not in SAME_TYPE and r not in joins]
+            hint = (f" — a {st} joins a {dt} with {', '.join(joins)}" if joins else "") + \
+                   (f"; the other way round, a {dt} joins a {st} with {', '.join(back)}" if back else "")
             raise GraphError(f"{rel} can't join {st} → {dt} (allowed: {', '.join(sorted(srcs))} → "
-                             f"{', '.join(sorted(dsts))})")
+                             f"{', '.join(sorted(dsts))}){hint}")
         if rel in SAME_TYPE and st != dt:
             raise GraphError(f"{rel} joins two nodes of the same type")
         if src == dst:
@@ -577,6 +582,19 @@ class Graph:
                 if type == "claim":
                     body = self._bind_measurements(s, body, inv)
                     staged["body"] = body
+                    # a measurement names the result its number comes from: that result supports the claim, so the
+                    # standing counts it as a line of support without a separate link from the writer
+                    for m in body.get("measurements") or []:
+                        rid = m.get("result") if isinstance(m, dict) else None
+                        if rid not in s.nodes:
+                            rid = next((i for i, n in s.nodes.items() if n.get("code") == rid and n["inv"] == inv), None)
+                        if rid and s.nodes[rid]["type"] == "result" and rid != nid and not any(
+                                (a == rid and b == nid and rel == "supports") or (a == nid and b == rid and rel == "derived_from")
+                                for a, rel, b in pending):
+                            a, rel, b, _f = self._orient(s, rid, "supports", nid)
+                            self._check_link(s, a, rel, b)
+                            pending.append((a, rel, b))
+                            links.append({"rel": "supports", "from": rid, "why": "a measurement of this claim is this result's"})
                 if type == "claim" and author not in P.curators:
                     problems = claim_issues(s, body, self._support_ids(s, nid, pending), inv)
                     loose = [w for p in problems if p.code == "UNBOUND_NUMBER" for w in p.words]
@@ -658,9 +676,17 @@ class Graph:
     @staticmethod
     def _auto_bind(s: D.Snap, body: dict, inv: str, author: str, support: list[str], loose: list[str]) -> tuple:
         """Bind the statement's loose numbers to results the claim already links, then to the author's own results
-        in this investigation (newest first). Small integers (≤ 12) bind only to counts (k, n), never to a value, so
-        a limit or a day of the month can't borrow a field by coincidence. Returns (body, results to link, notes)."""
+        in this investigation (newest first). Small integers (≤ 12) bind only to counts (k, n) — or to a value whose
+        field the sentence names ("0 trades" to `oos_trades`, "capacity is 7" to `capacity_total`) — never to an
+        unnamed value, so a limit or a day of the month can't borrow a field by coincidence.
+        Returns (body, results to link, notes)."""
+        import re as _re
         from .checks import _arm, _matches, _nums, numbers
+
+        def named(key: str, text: str) -> bool:
+            words = [w for w in _re.split(r"[^a-z0-9]+", key.lower()) if len(w) >= 3]
+            low = text.lower()
+            return bool(words) and any(_re.search(r"\b" + _re.escape(w), low) for w in words)
         stmt = body.get("statement", "")
         linked = [x for x in support if (s.nodes.get(x) or {}).get("type") == "result"]
         mine = sorted((i for i, n in s.nodes.items() if n["type"] == "result" and n["inv"] == inv
@@ -686,6 +712,9 @@ class Graph:
                 arm = _arm(rv)
                 vals = ([float(arm[0]), float(arm[1])] if arm else []) if small else _nums(rv) + \
                     ([arm[0] / arm[1]] if arm else [])
+                if small and not arm and isinstance(rv.get("value"), (int, float)) and not isinstance(rv.get("value"), bool) \
+                        and named(key, stmt):
+                    vals = [float(rv["value"])]
                 if vals and _matches(printed, vals):
                     m = {"name": key, "result": rid, "key": key}
                     if arm:

{hypgraph-0.4.1 → hypgraph-0.4.3}/src/hypgraph/language.py

@@ -64,9 +64,21 @@ _ZERO_ON_A_SCALE = re.compile(r"\b(below|above|near|to|from|of|than|at|cross(?:e
                               re.I)
 
 
+# a sentence that asks: it ends with a question mark (markdown emphasis or a closing quote may follow it)
+_INTERROGATIVE = re.compile(r"\?\s*[*_\"'’”)\]]*\s*$")
+
+
+def interrogative(text: str) -> bool:
+    """Does the sentence ask rather than assert? "Is A significantly better than B?" asserts nothing — found when a
+    lead headed a report section with the question it was answering and lost the report to the significance check."""
+    return bool(_INTERROGATIVE.search((text or "").strip()))
+
+
 def asserted(pattern: re.Pattern, text: str) -> list[str]:
     """The distinct matches of a pattern that their sentence actually asserts: not negated in their clause, not an
-    epistemic hedge ("cannot conclude"), and not a number on a scale ("below zero")."""
+    epistemic hedge ("cannot conclude"), not a number on a scale ("below zero"), and nothing in a question."""
+    if interrogative(text):
+        return []
     out = []
     for m in pattern.finditer(text or ""):
         if negated(text, m.start()):

{hypgraph-0.4.1 → hypgraph-0.4.3}/src/hypgraph/report_check.py

@@ -71,6 +71,10 @@ _NEGATOR = re.compile(r"\b(not|cannot|can't|never|no|nor|without|hardly|unlikely
                       r"doesn't|didn't|won't)\b[\w\s-]{0,24}$", re.I)
 
 
+def _norm(text: str) -> str:
+    return re.sub(r"[^a-z0-9]+", " ", (text or "").lower()).strip()
+
+
 def _own_words(sentence: str) -> str:
     """The writer's own words: quoted passages (often the very wording being corrected) blanked out."""
     return _QUOTE.sub(lambda m: " " * len(m.group(0)), sentence)
@@ -152,6 +156,10 @@ def check(g: "Graph", text: str, inv: str = "") -> dict:
         if n["code"] and (n["inv"] in invs or i in invs):
             by_code.setdefault(n["code"], []).append(i)
     plain, stat = _allowed(s, invs)
+    # the investigations' own questions: a report may quote the question it answers without asserting it
+    qtexts = [_norm(n["body"].get("text", "")) for i, n in s.nodes.items()
+              if n["type"] == "question" and (n["inv"] in invs or i in invs)]
+    qtexts = [q for q in qtexts if len(q) >= 20]
     findings: list[dict] = []
     counted = {"sentences": 0, "numbers": 0, "codes": 0}
 
@@ -170,6 +178,7 @@ def check(g: "Graph", text: str, inv: str = "") -> dict:
                 continue
             counted["sentences"] += 1
             own = _own_words(sent)
+            asks = L.interrogative(sent) or any(q in _norm(sent) for q in qtexts)
             qualified = bool(_QUALIFIED.search(sent))
             settled = _asserted(_SETTLED, own)
             cited = []
@@ -208,6 +217,8 @@ def check(g: "Graph", text: str, inv: str = "") -> dict:
                     add(ln, "warning", "REPORT_OMITS_DISPUTE", sent,
                         f"{code} is {'contested' if review == 'contested' else 'at risk'} in the record — say so where "
                         "you cite it.")
+            if asks:                     # a question, or the question's own words: citations checked, nothing asserted
+                continue
             # numbers
             for p in numbers(sent):
                 if _skip_number(p, sent) or re.search(rf"(?<![\w-])[A-Z]{{1,3}}{re.escape(p[3])}(?![\w-])", sent):

{hypgraph-0.4.1 → hypgraph-0.4.3}/src/hypgraph/schema.py

@@ -101,6 +101,24 @@ RELS: dict[str, tuple[set, set]] = {
     "settles": ({"decision"}, {"task"}),
 }
 REPLICATION = ("same_code", "new_seed", "new_impl", "new_data", "new_env")
+# What writers call the enum values. Mapped before validation, by (type, field); the stored value is canonical.
+SYNONYMS: dict[tuple[str, str], dict[str, str]] = {
+    ("result", "outcome"): {"success": "positive", "succeeded": "positive", "successful": "positive", "pass": "positive",
+                          "passed": "positive", "ok": "positive", "yes": "positive", "confirmed": "positive",
+                          "supported": "positive", "no": "negative", "refuted": "negative", "disconfirmed": "negative",
+                          "null": "negative", "unclear": "inconclusive", "mixed": "inconclusive",
+                          "indeterminate": "inconclusive", "error": "failed", "crashed": "failed", "fail": "failed",
+                          "failure": "failed", "skip": "skipped", "not_run": "skipped"},
+    ("result", "kind"): {"calculated": "computed", "derived": "computed", "measured": "observed", "empirical": "observed",
+                       "quoted": "cited", "literature": "cited"},
+    ("claim", "kind"): {"fact": "finding", "result": "finding", "observation": "finding", "measurement": "finding",
+                      "conclusion": "finding", "rule_out": "exclusion", "ruled_out": "exclusion", "negative": "exclusion",
+                      "undetermined": "inconclusive", "unclear": "inconclusive", "definition": "convention",
+                      "notation": "convention", "hunch": "lead", "idea": "lead"},
+    ("run", "state"): {"success": "succeeded", "successful": "succeeded", "done": "succeeded", "completed": "succeeded",
+                      "complete": "succeeded", "ok": "succeeded", "error": "failed", "failure": "failed", "fail": "failed",
+                      "crashed": "failed", "timed_out": "timeout", "killed": "cancelled", "stopped": "interrupted"},
+}
 # what a node rests on: if the far end falls, this node is at risk (a work order is moot)
 RISKY = ("requires", "derived_from", "based_on", "works_on", "rests_on")
 SAME_TYPE = ("supersedes", "corrects")

{hypgraph-0.4.1 → hypgraph-0.4.3}/tests/test_engine_fixes.py

@@ -101,15 +101,14 @@ def test_binding_prefers_linked_results_and_only_the_authors_own(env):
     assert other
 
 
-def test_small_integers_bind_only_to_counts(env):
+def test_small_integers_bind_only_to_counts_or_a_named_value(env):
     g, me, inv, r = env
     me.add("result", inv, summary="Seven of nine probes leaked.", values={"leaks": {"k": 7, "n": 9}, "limit": {"value": 5}})
-    with pytest.raises(GraphError) as e:                   # 5 is not bound to the value field 'limit'
-        me.add("claim", inv, statement="7 of 9 probes leaked, against a limit of 5 mg/L.", scope=SCOPE)
+    with pytest.raises(GraphError) as e:                   # 5 is not bound to 'limit' when the sentence doesn't name it
+        me.add("claim", inv, statement="7 of 9 probes leaked, 5 of them twice.", scope=SCOPE)
     assert e.value.problems[0]["words"] == ["5"]
-    n = me.add("claim", inv, statement="7 of 9 probes leaked, against a limit of 5 mg/L.",
-               scope=SCOPE + " The limit is 5 mg/L.")       # a design constant belongs in the scope
-    assert {m["key"] for m in n["body"]["measurements"]} == {"leaks"}
+    n = me.add("claim", inv, statement="7 of 9 probes leaked, against a limit of 5 mg/L.", scope=SCOPE)
+    assert {m["key"] for m in n["body"]["measurements"]} == {"leaks", "limit"}   # 0.4.3: the sentence names the field
 
 
 def test_revise_binds_too(env):

hypgraph-0.4.3/tests/test_questions_not_assertions.py

@@ -0,0 +1,43 @@
+"""0.4.2: a question is not an assertion. From the first real HypSwarm mixed-swarm run: the lead headed a report
+section with the question it was answering and the report was refused three times for 'significantly'."""
+from hypgraph import Graph, Policy
+from hypgraph import language as L
+
+
+def test_interrogatives_assert_nothing():
+    assert L.asserted(L.SIGNIFICANCE, "Is A significantly more accurate than B?") == []
+    assert L.asserted(L.SIGNIFICANCE, "**Q2 — Is A significantly more accurate than B at the two-sided 0.05 level?**") == []
+    assert L.asserted(L.ABSOLUTE, "Does it never fail?") == []
+    assert L.asserted(L.SIGNIFICANCE, "A is significantly more accurate than B.") == ["significantly"]
+    assert L.interrogative("Is it so?\"") and not L.interrogative("It is so.")
+
+
+def _record():
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    inv = g.create(author="h", type="investigation", fields={"title": "Does A beat B.", "objective": "Compare A and B on the same items."})["id"]
+    q = g.create(author="h", type="question", inv=inv, code="Q2",
+                 fields={"text": "Is A significantly more accurate than B (two-sided, 0.05)?"})["id"]
+    r = g.create(author="stats", type="run", inv=inv, fields={"kind": "agent", "name": "mcnemar", "state": "succeeded"})
+    rs = g.create(author="stats", type="result", inv=inv, fields={"summary": "Compared A and B on the same 1,000 items.",
+                                                                  "values": {"a": {"k": 900, "n": 1000}, "b": {"k": 800, "n": 1000}}},
+                  links=[{"rel": "produced", "from": r["id"]}])
+    c = g.create(author="stats", type="claim", inv=inv, fields={"statement": "A is right on 900 of 1000 items and B on 800 of 1000.",
+                                                                "scope": "The 1,000 shared items."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs["id"]}])
+    g.review(author="critic", target=c["id"], verdict="checked", method="Recounted both columns from the file.", notes="The counts hold and the claim says what the result says.")
+    return g, inv, c["code"]
+
+
+def test_a_report_may_quote_the_question_it_answers():
+    g, inv, cl = _record()
+    text = ("## Q2 — Is A significantly more accurate than B at the two-sided 0.05 level?\n\n"
+            f"A is right on 900 of 1000 items and B on 800 of 1000 ({cl}).\n\n"
+            "The question 'Is A significantly more accurate than B (two-sided, 0.05)?' is what this section answers.\n")
+    r = g.check_text(text, inv)
+    assert not [f for f in r["findings"] if f["code"] == "REPORT_SIGNIFICANCE_UNBACKED"], r["findings"]
+    assert r["ok"]
+    # the assertion itself is still caught, and an unknown code in a question heading is still an unknown code
+    bad = g.check_text("A is significantly more accurate than B.", inv)
+    assert any(f["code"] == "REPORT_SIGNIFICANCE_UNBACKED" and f["level"] == "error" for f in bad["findings"])
+    unk = g.check_text("## Is CL99 significantly better?", inv)
+    assert any(f["code"] == "REPORT_UNKNOWN_CODE" for f in unk["findings"])

{hypgraph-0.4.1 → hypgraph-0.4.3}/tests/test_refusals.py

@@ -128,7 +128,8 @@ def test_significance_is_tested_from_the_counts(env):
     p = refused(env, "Model A is significantly better than model B.", [M(env[3], "p", "p_ab", value=0.21)] + close,
                 scope="1,000 items each, one seed.")
     assert codes(p) == ["SIGNIFICANCE_NOT_SHOWN"]
-    assert "SIGNIFICANCE_WITHOUT_TEST" in codes(refused(env, "The fine-tune is significantly better."))
+    # 0.4.3: the supporting result carries p_ab = 0.21, a named p-value — that test backs the word and fails it
+    assert "SIGNIFICANCE_NOT_SHOWN" in codes(refused(env, "The fine-tune is significantly better."))
 
 
 def test_causes_need_an_intervention(env):

hypgraph-0.4.3/tests/test_vocabulary_friction.py

@@ -0,0 +1,130 @@
+"""0.4.3: the five vocabulary-friction fixes from the discovery study (HypSwarm studies/discovery/LIB-NOTES.md
+items 1, 2, 4, 5, 10). Each test is the sentence a real model wrote and was refused for."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+H = "harness"
+
+
+def _g():
+    g = Graph(policy=Policy(reviewers={"critic"}, extra_reserved={H}))
+    inv = g.create(author=H, type="investigation", fields={"title": "Does A beat B.", "objective": "Compare A and B on the same items."})["id"]
+    q = g.create(author=H, type="question", inv=inv, code="Q2", fields={"text": "Is A significantly more accurate than B?"})["id"]
+    return g, inv, q
+
+
+def _result(g, inv, author, values, summary="Measured what the question asks."):
+    r = g.create(author=author, type="run", inv=inv, fields={"kind": "agent", "name": "a run", "state": "succeeded"})
+    return g.create(author=author, type="result", inv=inv, fields={"summary": summary, "values": values},
+                    links=[{"rel": "produced", "from": r["id"]}])["id"]
+
+
+# ── item 1: a named p-value is a test ─────────────────────────────────────────
+def test_a_named_p_value_backs_significantly():
+    g, inv, q = _g()
+    rs = _result(g, inv, "stats", {"acc_a": {"value": 0.837}, "acc_b": {"value": 0.796}, "p_exact": {"value": 0.0169}},
+                 "Exact McNemar test on the paired items.")
+    c = g.create(author="stats", type="claim", inv=inv,
+                 fields={"statement": "A is significantly more accurate than B (0.837 vs 0.796, exact McNemar p = 0.0169).",
+                         "scope": "The 1,000 paired items; two-sided test at 0.05."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])
+    assert c["code"].startswith("CL")
+
+
+def test_a_named_p_value_above_the_threshold_is_quoted_back():
+    g, inv, q = _g()
+    rs = _result(g, inv, "stats", {"acc_a": {"value": 0.805}, "acc_b": {"value": 0.781}, "p_mcnemar": {"value": 0.208}})
+    with pytest.raises(GraphError, match="SIGNIFICANCE_NOT_SHOWN"):
+        g.create(author="stats", type="claim", inv=inv,
+                 fields={"statement": "A is significantly more accurate than B (0.805 vs 0.781, p = 0.208).",
+                         "scope": "The 1,000 paired items; two-sided test at 0.05."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])
+
+
+def test_a_supporting_results_p_field_counts_even_when_the_sentence_omits_it():
+    g, inv, q = _g()
+    rs = _result(g, inv, "stats", {"acc_a": {"value": 0.837}, "acc_b": {"value": 0.796}, "p_value": {"value": 0.017}})
+    c = g.create(author="stats", type="claim", inv=inv,
+                 fields={"statement": "A is significantly more accurate than B (0.837 against 0.796).",
+                         "scope": "The 1,000 paired items; exact McNemar, two-sided at 0.05."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])
+    assert c["code"].startswith("CL")
+
+
+def test_significantly_with_no_test_anywhere_is_still_refused():
+    g, inv, q = _g()
+    rs = _result(g, inv, "stats", {"acc_a": {"value": 0.837}, "acc_b": {"value": 0.796}})
+    with pytest.raises(GraphError, match="SIGNIFICANCE_WITHOUT_TEST"):
+        g.create(author="stats", type="claim", inv=inv,
+                 fields={"statement": "A is significantly more accurate than B (0.837 against 0.796).", "scope": "The 1,000 paired items."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])
+
+
+# ── item 2: a bound measurement's result supports the claim ───────────────────
+def test_a_measurement_counts_as_a_line_of_support():
+    g, inv, q = _g()
+    rs = _result(g, inv, "analyst", {"acc_a": {"k": 805, "n": 1000}})
+    c = g.create(author="analyst", type="claim", inv=inv,
+                 fields={"statement": "A is right on 805 of 1000 items.", "scope": "The 1,000 items in items.csv.",
+                         "measurements": [{"name": "acc_a", "result": rs, "key": "acc_a", "k": 805, "n": 1000}]},
+                 links=[{"rel": "answers", "to": q}])
+    st = g.get(c["id"])["state"]
+    assert "1 independent line of support" in st["sentence"], st["sentence"]
+    assert any(e["rel"] == "supports" and e["src"] == rs for e in g.get(c["id"])["in"])
+
+
+# ── item 4: a wrong relation names the right one ──────────────────────────────
+def test_a_wrong_relation_names_the_ones_that_join():
+    g, inv, q = _g()
+    r = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "pytest", "state": "succeeded"})
+    with pytest.raises(GraphError) as e:
+        g.create(author="w", type="result", inv=inv, fields={"summary": "Ran the tests.", "values": {"passed": {"k": 4, "n": 5}}},
+                 links=[{"rel": "executes", "from": r["id"]}])          # a run "executes" the result it produced: wrong relation
+    msg = str(e.value)
+    assert "executes can't join run → result" in msg and "a run joins a result with produced" in msg         and "a result joins a run with derived_from" in msg
+
+
+# ── item 5: enum synonyms ─────────────────────────────────────────────────────
+def test_enum_synonyms_are_stored_canonically():
+    g, inv, q = _g()
+    r = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "pytest", "state": "done"})
+    assert g.get(r["id"])["body"]["state"] == "succeeded"
+    rs = g.create(author="w", type="result", inv=inv, fields={"summary": "Ran the tests.", "outcome": "success", "kind": "calculated",
+                                                             "values": {"passed": {"k": 5, "n": 5}}},
+                  links=[{"rel": "produced", "from": r["id"]}])
+    assert g.get(rs["id"])["body"]["outcome"] == "positive" and g.get(rs["id"])["body"]["kind"] == "computed"
+    c = g.create(author="w", type="claim", inv=inv, fields={"statement": "All 5 of 5 tests pass in tests/test_money.py.",
+                                                           "scope": "tests/test_money.py after the fix.", "kind": "fact"},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs["id"]}])
+    assert g.get(c["id"])["body"]["kind"] == "finding"
+    with pytest.raises(GraphError, match="must be one of"):
+        g.create(author="w", type="result", inv=inv, fields={"summary": "Ran the tests.", "outcome": "splendid"},
+                 links=[{"rel": "produced", "from": r["id"]}])
+
+
+# ── item 10: small integers bind to a value the sentence names ───────────────
+def test_a_small_integer_binds_to_the_field_the_sentence_names():
+    g, inv, q = _g()
+    rs = _result(g, inv, "quant", {"oos_trades": {"value": 0}, "fees": {"value": 0.001}, "slippage": {"value": 0.0005}})
+    c = g.create(author="quant", type="claim", inv=inv,
+                 fields={"statement": "The held-out window produced 0 trades after costs, too few to say anything about an edge.",
+                         "scope": "Days 600-999 of prices.csv; 10 bp fees and 5 bp slippage per side."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])
+    assert any(m["key"] == "oos_trades" for m in g.get(c["id"])["body"]["measurements"])
+    rs2 = _result(g, inv, "solver", {"capacity_total": {"value": 7}, "customers": {"value": 8}, "feasible": {"value": False}})
+    c2 = g.create(author="solver", type="claim", inv=inv,
+                  fields={"statement": "No feasible assignment exists: total capacity is 7 for 8 customers.",
+                          "scope": "instance.csv as given; depots d0, d1, d2."},            # the scope names no numbers: both must bind
+                  links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs2}])
+    keys = {m["key"] for m in g.get(c2["id"])["body"]["measurements"]}
+    assert {"capacity_total", "customers"} <= keys
+
+
+def test_an_unnamed_small_integer_still_does_not_borrow_a_value():
+    g, inv, q = _g()
+    rs = _result(g, inv, "quant", {"oos_trades": {"value": 7}})
+    with pytest.raises(GraphError, match="UNBOUND_NUMBER"):
+        g.create(author="quant", type="claim", inv=inv,
+                 fields={"statement": "The strategy wins 7 points.", "scope": "Days 600-999 of prices.csv."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])