hypgraph 0.2.0__tar.gz → 0.3.0__tar.gz

{hypgraph-0.2.0 → hypgraph-0.3.0}/AGENTS.md

@@ -65,10 +65,11 @@ reserved.
      are not;
    - `kind: "exclusion"` needs a result with `power: "demonstrated"` (a search that found a planted answer).
      Otherwise use `"inconclusive"`.
-   Each refusal ends in a code (`[ABSOLUTE_UNDERPOWERED]`) and already gives the honest sentence: use it.
+   Each refusal ends in a code (`[ABSOLUTE_UNDERPOWERED]`) and already gives the honest sentence: use it. Refusals
+   are logged per author (`refusal_log`); coming back with the honest version marks yours fixed.
 6. **Reviews.** Only reviewers named by the investigation (or the host's policy) set standing. Nobody reviews their
    own work. A revision makes earlier reviews stale.
-7. **Start summaries from `report()`.** It's generated from the record, so it can't restate a withdrawn claim. Write
+7. **Start summaries from `report()`, and run `check_report(text)` on the write-up before handing it over.** It's generated from the record, so it can't restate a withdrawn claim. Write
    your interpretation underneath it.
 
 ## Reading standing

{hypgraph-0.2.0 → hypgraph-0.3.0}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.3.0 — 2026-10-24
+
+- **The refusal log.** Every refused claim is logged: author, statement, codes, messages. A later accepted claim by
+  the same author that says the same thing (same node, or ≥ 30% shared content words within 24 hours) marks the
+  refusal fixed. Append-only, with its own hash chain (`verify_refusals()`); the record's chain is untouched.
+  - API: `refusals()`, `refusal_report()`.
+  - CLI: `hypgraph refusals [--author …]`. MCP: `refusal_log`. HTTP: `GET /api/graph/refusals`.
+  - Atlas: an "Overclaims caught" card in the Work view.
+- **`hypgraph check report.md`** lints a write-up against the record (`Graph.check_text`; MCP `check_report`; HTTP
+  `POST /api/graph/check`). Exits 1 on errors (`--strict`: warnings too).
+  - Errors: citations of withdrawn nodes, settled language about unchecked, contested or at-risk work, unknown
+    codes, and unbacked never / no effect / significantly.
+  - Warnings: numbers no result contains or implies, omitted disputes, superseded citations, uncited causal
+    language.
+  - Calibrated on 24 real PegasusDMZ write-ups against its live record. That fixed negations ("cannot be proven"),
+    quoted passages under correction, instructions ("never use the eval set"), p-values given in the sentence, and
+    "results in" as a noun phrase.
+- An absolute whose statement gives its n ("no leaks in 50 prompts", "nothing in 50 of 50") is scoped to what was
+  seen and accepted; its standing still carries the bound. Without n it is refused, as before.
+- Spec draft 3 (§8 refusal log, §9 checking a write-up).
+
 ## 0.2.0 — 2026-10-24
 
 **Refusal, remastered.** The claim checks now do the arithmetic the writer skipped, and every refusal says what the

{hypgraph-0.2.0 → hypgraph-0.3.0}/CITATION.cff

@@ -13,7 +13,7 @@ authors:
     affiliation: VoodooMods LLC
   - name: VoodooMods LLC
 license: Apache-2.0
-version: 0.2.0
+version: 0.3.0
 date-released: "2026-10-24"
 url: "https://hypgraph.com"
 repository-code: "https://github.com/voodoomods/hypgraph"

{hypgraph-0.2.0 → hypgraph-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.2.0
+Version: 0.3.0
 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/
@@ -82,6 +82,33 @@ Every refusal has a stable code, the arithmetic, and the sentence that *would* b
 claim in one step. `hypgraph bound 0 50 --exposure 1e6` (or the MCP tool `bound`) answers "what does my count
 actually support?" before anyone writes the word.
 
+Every refusal is also **logged**: who tried to say what, which rules caught it, and whether they came back with
+the honest version.
+
+```text
+$ hypgraph refusals
+## Overclaims caught — 4 refused, 3 came back honest
+| author  | refused | fixed | open | most common |
+| analyst | 4       | 3     | 1    | EXCLUSION_WITHOUT_POWER ×1, ABSOLUTE_UNDERPOWERED ×1, UNBOUND_NUMBER ×1 |
+### Latest
+- analyst: “Prompt format makes no difference to accuracy.” — EXCLUSION_WITHOUT_POWER → not fixed
+- analyst: “The model never leaks training data.” — ABSOLUTE_UNDERPOWERED → fixed as CL2
+- analyst: “The fine-tune is 5 points better than the baseline.” — UNBOUND_NUMBER → fixed as CL1
+- analyst: “The fine-tune always beats the baseline.” — ABSOLUTE_WITHOUT_COUNT, COMPARATIVE_WITHOUT_COMPARISON → fixed as CL1
+```
+
+And because most hype lives in the write-up, not the record, **`hypgraph check summary.md`** lints the final report
+against the record. It catches numbers no result contains, claims called "established" that the record has as
+unchecked or contested, citations to withdrawn claims, and "never" / "no effect" / "significantly" with nothing
+behind them. It exits 1 on errors, so it can gate CI:
+
+```text
+$ hypgraph check summary.md
+summary.md:8: error REPORT_OVERSTATES_STANDING: 'established' — but CL2 is unchecked in the record …
+summary.md:9: warning REPORT_UNSOURCED_NUMBER: 700 isn't in any result, measurement, claim, scope or constant …
+summary.md:13: error REPORT_UNKNOWN_CODE: CL9 isn't in the record for this investigation — a citation to nothing.
+```
+
 And when something does fall, the record says what falls with it:
 
 ```text
@@ -116,7 +143,7 @@ hypgraph skill --install                                                     # +
 The server writes as one author, fixed when it starts. The agent can't pass another name or write as your job runner,
 and its verdicts count only if you name it as a reviewer. Tools: `overview`, `find`, `show`, `start_investigation`,
 `add`, `link`, `revise`, `withdraw`, `retract_link`, `review`, `next_experiments`, `work_queue`, `claim_work`,
-`register_run`, `bound`, `report`, `verify`, `schema`. The method is in [AGENTS.md](https://github.com/voodoomods/hypgraph/blob/main/AGENTS.md); the short version is
+`register_run`, `bound`, `check_report`, `refusal_log`, `report`, `verify`, `schema`. The method is in [AGENTS.md](https://github.com/voodoomods/hypgraph/blob/main/AGENTS.md); the short version is
 [llms.txt](https://hypgraph.com/llms.txt).
 
 ## Wire it into your system

{hypgraph-0.2.0 → hypgraph-0.3.0}/README.md

@@ -50,6 +50,33 @@ Every refusal has a stable code, the arithmetic, and the sentence that *would* b
 claim in one step. `hypgraph bound 0 50 --exposure 1e6` (or the MCP tool `bound`) answers "what does my count
 actually support?" before anyone writes the word.
 
+Every refusal is also **logged**: who tried to say what, which rules caught it, and whether they came back with
+the honest version.
+
+```text
+$ hypgraph refusals
+## Overclaims caught — 4 refused, 3 came back honest
+| author  | refused | fixed | open | most common |
+| analyst | 4       | 3     | 1    | EXCLUSION_WITHOUT_POWER ×1, ABSOLUTE_UNDERPOWERED ×1, UNBOUND_NUMBER ×1 |
+### Latest
+- analyst: “Prompt format makes no difference to accuracy.” — EXCLUSION_WITHOUT_POWER → not fixed
+- analyst: “The model never leaks training data.” — ABSOLUTE_UNDERPOWERED → fixed as CL2
+- analyst: “The fine-tune is 5 points better than the baseline.” — UNBOUND_NUMBER → fixed as CL1
+- analyst: “The fine-tune always beats the baseline.” — ABSOLUTE_WITHOUT_COUNT, COMPARATIVE_WITHOUT_COMPARISON → fixed as CL1
+```
+
+And because most hype lives in the write-up, not the record, **`hypgraph check summary.md`** lints the final report
+against the record. It catches numbers no result contains, claims called "established" that the record has as
+unchecked or contested, citations to withdrawn claims, and "never" / "no effect" / "significantly" with nothing
+behind them. It exits 1 on errors, so it can gate CI:
+
+```text
+$ hypgraph check summary.md
+summary.md:8: error REPORT_OVERSTATES_STANDING: 'established' — but CL2 is unchecked in the record …
+summary.md:9: warning REPORT_UNSOURCED_NUMBER: 700 isn't in any result, measurement, claim, scope or constant …
+summary.md:13: error REPORT_UNKNOWN_CODE: CL9 isn't in the record for this investigation — a citation to nothing.
+```
+
 And when something does fall, the record says what falls with it:
 
 ```text
@@ -84,7 +111,7 @@ hypgraph skill --install                                                     # +
 The server writes as one author, fixed when it starts. The agent can't pass another name or write as your job runner,
 and its verdicts count only if you name it as a reviewer. Tools: `overview`, `find`, `show`, `start_investigation`,
 `add`, `link`, `revise`, `withdraw`, `retract_link`, `review`, `next_experiments`, `work_queue`, `claim_work`,
-`register_run`, `bound`, `report`, `verify`, `schema`. The method is in [AGENTS.md](https://github.com/voodoomods/hypgraph/blob/main/AGENTS.md); the short version is
+`register_run`, `bound`, `check_report`, `refusal_log`, `report`, `verify`, `schema`. The method is in [AGENTS.md](https://github.com/voodoomods/hypgraph/blob/main/AGENTS.md); the short version is
 [llms.txt](https://hypgraph.com/llms.txt).
 
 ## Wire it into your system

{hypgraph-0.2.0 → hypgraph-0.3.0}/docs/spec.md

@@ -1,6 +1,6 @@
 # The HypGraph record format — `hypgraph/1`
 
-Status: draft 2 (HypGraph 0.2). Licence: CC BY 4.0. This page is enough to write another implementation, a
+Status: draft 3 (HypGraph 0.3). Licence: CC BY 4.0. This page is enough to write another implementation, a
 verifier or a viewer.
 
 ## 1. Model
@@ -175,7 +175,7 @@ smallest detectable difference uses 80% power at two-sided α = 0.05.
 | 4 | `UNBOUND_NUMBER` | a number in the statement (digits, or the words two to twenty; digits in quotes are names) is not one of: a bound measurement's numbers; for a count, its rate, complement or n − k; for any two measurements, their difference, ratios, relative change or sum; the scope's numbers; the investigation's `constants`; or the conventions 95 / 99 / 90 / 80 / 0.05 / 0.01 when the statement speaks of intervals, bounds, confidence, power or significance. *Statistical* quantities (a rate's 95% bounds; for two counts the difference interval, p-value and detectable difference) count only when written to at least one decimal place. |
 | 5 | `ABSOLUTE_WITHOUT_COUNT` | an absolute word (never, always, all, every, none, impossible, cannot, proves, certainly, guaranteed, eliminates, entirely, completely, universally, consistently, perfect, solves, zero, 100%, …) with no bound count where k is 0 or n |
 | 5a | `ABSOLUTE_UNRELATED_COUNT` | the counts with k ∈ {0, n} share no content word with the statement in their name or key |
-| 5b | `ABSOLUTE_UNDERPOWERED` | the 95% bound on the opposite rate is above 5%. The message gives the honest wording and the trials needed for a 1-in-1,000 bound. |
+| 5b | `ABSOLUTE_UNDERPOWERED` | the 95% bound on the opposite rate is above 5% and the statement doesn't say n ("never leaks" rather than "no leaks in 50 prompts" — a statement that gives its n is scoped to what was seen, and accepted). The message gives the honest wording and the trials needed for a 1-in-1,000 bound. |
 | 5c | `ABSOLUTE_HIDES_DENOMINATOR` | the count is enough, but n appears in neither the statement nor the scope |
 | 6 | `CONVENTION_HEDGED` | a `convention` hedges (could, might, suggests, consistent with, …) |
 | 7 | `COMPARATIVE_WITHOUT_COMPARISON` | a comparative (better, beats, outperforms, higher than, improves, exceeds, …) with fewer than two measured sides, no bound p-value or interval, and no supporting claim that binds two sides |
@@ -191,3 +191,39 @@ standing carries `bounds` (per count: k, n, rate, lo, hi and, with exposure, `un
 
 **Blast radius.** Withdrawing a node, or a verdict that makes it fall, returns `blast_radius`: every node resting on it
 by type, with claims and decisions named and, if a spend meter is connected, the cost of the work behind them.
+
+## 8. The refusal log
+
+A refused claim never enters the record, so its trace lives in a separate append-only table, `refusal_log`, with
+its own SHA-256 chain over `canon({at, kind, author, inv, node, op, statement, codes, detail, ref, prev})`. The
+record's own chain and `verify()` are unaffected.
+
+- `kind: refused`: the author, the investigation, the statement (≤ 1,500 characters), the sorted codes, and the
+  problems (code, message, fix) it was refused with. `op` is `create` or `revise`; `node` is set for a revision.
+- `kind: fixed`: a later claim or revision by the same author in the same investigation, accepted within 24 hours,
+  that says the same thing. "The same" means the same node for a revision; otherwise a Jaccard overlap ≥ 0.3 of the
+  statements' content words. `ref` is the refusal it fixes.
+
+A report aggregates per author (refused, fixed, open, codes) and per rule.
+
+## 9. Checking a write-up against the record
+
+A checker reads markdown sentence by sentence and checks it against the record. Code blocks, inline code, URLs, link
+targets and HTML comments are skipped. Quoted passages and negated words ("cannot be proven") are not treated as
+the writer's assertion. Codes are matched within the investigation being reported on.
+
+| level | code | when |
+|---|---|---|
+| error | `REPORT_CITES_WITHDRAWN` | a sentence cites a withdrawn node and doesn't say so (withdrawn, retracted, failed, superseded, earlier, …) |
+| error | `REPORT_OVERSTATES_STANDING` | settled language (confirmed, established, shown, proven, holds, …) about a claim or hypothesis that is unchecked, stale, contested or at risk, or a result that is contested or at risk |
+| error | `REPORT_UNKNOWN_CODE` | an `INV` / `RUN` / `CL` / `RS` / `RV` code the investigation doesn't have |
+| error | `REPORT_ABSOLUTE_UNBACKED` | never / always / impossible / guaranteed / eliminates / proven / 100% asserted, not in an instruction, with no cited claim carrying a count with k ∈ {0, n} |
+| error | `REPORT_ABSENCE_UNBACKED` | "no effect" / "rules out" / "doesn't matter" without citing a claim filed as `exclusion` or `inconclusive` |
+| error | `REPORT_SIGNIFICANCE_UNBACKED` | "significantly" without a p-value or interval in the sentence and without citing a node that carries a test (a negated "not significant" is a warning) |
+| warning | `REPORT_UNSOURCED_NUMBER` | a number not contained in or implied by the investigation's results, live claims' measurements, statements and scopes, the investigation's scope and constants, or experiment and run settings. Integers ≤ 12, years, dates, times and 7-digit+ ids are skipped. Statistical quantities need one decimal. |
+| warning | `REPORT_OMITS_DISPUTE` | cites a contested or at-risk node without saying so |
+| warning | `REPORT_CITES_SUPERSEDED` | cites a superseded node without saying so |
+| warning | `REPORT_CAUSAL_UNCITED` | causal language with no node cited |
+| note | `REPORT_BOUND` | an absolute backed by a cited count: what the count supports |
+
+Calibrated on 24 real write-ups from PegasusDMZ against its live record.

{hypgraph-0.2.0 → hypgraph-0.3.0}/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.2.0"
+__version__ = "0.3.0"
 
 from .bundle import verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.2.0 → hypgraph-0.3.0}/src/hypgraph/checks.py

@@ -13,8 +13,9 @@ and each refusal does the arithmetic the writer skipped, then offers the honest
                                 computed from them (difference, ratio, percentage, interval), the scope or a constant
   ABSOLUTE_WITHOUT_COUNT        "never" / "always" / "eliminates" / "100%" with no count of 0 or n behind it
   ABSOLUTE_UNRELATED_COUNT      the 0-of-n it leans on counts something else
-  ABSOLUTE_UNDERPOWERED         0 of n, but n is too small: the rate could still be above 5%
-  ABSOLUTE_HIDES_DENOMINATOR    0 of n is enough, but the statement doesn't say n — so "never" reads as never
+  ABSOLUTE_UNDERPOWERED         0 of n with n too small (the rate could still be above 5%), and the statement
+                                generalises past the n trials instead of saying them ("never leaks")
+  ABSOLUTE_HIDES_DENOMINATOR    0 of n is enough, but neither statement nor scope says n — "never" reads as never
   COMPARATIVE_WITHOUT_COMPARISON "beats" / "outperforms" / "higher than" with fewer than two sides measured
   SIGNIFICANCE_WITHOUT_TEST     "significantly" with no test behind it
   SIGNIFICANCE_NOT_SHOWN        the test behind it isn't significant
@@ -211,6 +212,10 @@ def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
     opposite = hi if k == 0 else 1 - lo               # how often the opposite could still happen
     seen = f"{k} of {n:,}"
     what = "it happening" if k == 0 else "it failing"
+    in_statement = n in {round(v) for v, *_ in numbers(stmt)}
+    in_scope = n in {round(v) for v, *_ in numbers(scope)}
+    if in_statement:
+        return []          # scoped to the trials it states ("nothing in 50 prompts"); its standing carries the bound
     if opposite > UNDERPOWERED:
         need = stats.trials_for(0.001)
         honest = (f"'no {'occurrences' if k == 0 else 'exceptions'} in {n:,} trials (95% upper bound "
@@ -220,14 +225,13 @@ def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
                         f"time (95% upper bound). Honest version: {honest}. To support a rate below 1 in 1,000 you "
                         f"need about {need:,} trials without one." + _exposure_note(opposite, body),
                         fix=honest.strip("'"), words=words)]
-    stated = {round(v) for v, *_ in numbers(f"{stmt} {scope}")}
-    if n not in stated:
-        return [Problem("ABSOLUTE_HIDES_DENOMINATOR",
-                        f"'{w}' rests on {seen} — say the {n:,} in the statement or scope, so readers can see what "
-                        f"'{w}' means here: {what} no more than {stats.pct(opposite)} of the time "
-                        f"({stats.one_in(opposite)}, 95% upper bound)." + _exposure_note(opposite, body),
-                        fix=f"add 'in {n:,} trials'", words=words)]
-    return []
+    if in_scope:
+        return []          # enough trials, and the scope says how many
+    return [Problem("ABSOLUTE_HIDES_DENOMINATOR",
+                    f"'{w}' rests on {seen} — say the {n:,} in the statement or scope, so readers can see what "
+                    f"'{w}' means here: {what} no more than {stats.pct(opposite)} of the time "
+                    f"({stats.one_in(opposite)}, 95% upper bound)." + _exposure_note(opposite, body),
+                    fix=f"add 'in {n:,} trials'", words=words)]
 
 
 def _measured_claim(s: Snap, support: list[str]) -> bool:

{hypgraph-0.2.0 → hypgraph-0.3.0}/src/hypgraph/cli.py

@@ -11,6 +11,8 @@ hypgraph — the command line.
     hypgraph show CL1 --why             what it rests on        (--impact: what rests on it, --history: versions)
     hypgraph report                     the facts, generated from the record
     hypgraph export -o study.json       a bundle anyone can verify:  hypgraph verify study.json
+    hypgraph check summary.md           lint a write-up against the record (exit 1 on errors)
+    hypgraph refusals                   the overclaims the record caught, per author
     hypgraph mcp                        an MCP server for agents (pip install "hypgraph[mcp]")
     hypgraph skill --install            the agent skill, into .claude/skills/hypgraph/SKILL.md
 
@@ -304,6 +306,35 @@ def cmd_demo(args) -> int:
     return 0
 
 
+def cmd_refusals(args) -> int:
+    g = _graph(args)
+    inv = g.resolve(args.inv) if args.inv else ""
+    if args.author_filter:
+        rows = g.refusals(inv=inv, author=args.author_filter, since=args.since)
+        _out(args, rows, "\n".join(f"{r['at'][:16]}  {', '.join(r['codes'])}\n    “{r['statement'][:160]}”"
+                                    + (f"\n    → fixed as {r['fixed_by']['node']}" if r["fixed_by"] else "")
+                                    for r in rows) or "No refusals.")
+        return 0
+    r = g.refusal_report(inv=inv, since=args.since)
+    _out(args, r, r["markdown"])
+    return 0
+
+
+def cmd_check(args) -> int:
+    g = _graph(args)
+    text = Path(args.file).read_text(encoding="utf-8") if args.file != "-" else sys.stdin.read()
+    r = g.check_text(text, g.resolve(args.inv) if args.inv else "")
+    if getattr(args, "json", False):
+        _out(args, r)
+    else:
+        name = args.file
+        for f in r["findings"]:
+            print(f"{name}:{f['line']}: {f['level']} {f['code']}: {f['message']}\n    “{f['excerpt']}”")
+        print(r["markdown"].splitlines()[0])
+    failed = r["errors"] > 0 or (args.strict and r["warnings"] > 0)
+    return 1 if failed else 0
+
+
 def cmd_bound(args) -> int:
     from .mcp import bound_text
     from . import stats
@@ -427,6 +458,14 @@ def build_parser() -> argparse.ArgumentParser:
     s.add_argument("bundle")
     cmd("demo", cmd_demo, "build the Broad Street (1854) teaching investigation")
     cmd("schema", cmd_schema, "the node types and relations")
+    s = cmd("refusals", cmd_refusals, "the overclaims the record caught: per author, per rule, fixed or open")
+    s.add_argument("--inv", default="")
+    s.add_argument("--since", default="", help="ISO date or time")
+    s.add_argument("--author", dest="author_filter", default="", help="list one author's refusals in full")
+    s = cmd("check", cmd_check, "lint a write-up (markdown) against the record; exit 1 on errors")
+    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.add_argument("k", type=int, help="how many times it happened")
     s.add_argument("n", type=int, help="how many trials")

{hypgraph-0.2.0 → hypgraph-0.3.0}/src/hypgraph/graph.py

@@ -27,7 +27,7 @@ from pathlib import Path
 from typing import Any, Callable, Optional
 
 from . import derive as D
-from . import store
+from . import refusals, store
 from .checks import claim_issues
 from .policy import Policy
 from .schema import REPLICATION, RELS, SAME_TYPE, TYPES, VERDICTS
@@ -138,6 +138,7 @@ class Graph:
         with self._lock:
             con = self._connect()
             store.install(con)
+            refusals.install(con)
 
     # ── connections ─────────────────────────────────────────────────
     def _connect(self) -> sqlite3.Connection:
@@ -569,8 +570,10 @@ class Graph:
                 if type == "claim" and author not in P.curators:
                     problems = claim_issues(s, body, self._support_ids(s, nid, pending), inv)
                     if problems:
-                        raise GraphError("claim refused:\n- " + "\n- ".join(p.text() for p in problems),
-                                         [p.to_dict() for p in problems])
+                        found = [p.to_dict() for p in problems]
+                        refusals.record_refusal(self, author=author, op="create", inv=inv, node="", body=body,
+                                                problems=found)
+                        raise GraphError("claim refused:\n- " + "\n- ".join(p.text() for p in problems), found)
 
                 def write(con):
                     self._rate(con, author)
@@ -591,6 +594,11 @@ class Graph:
         out = self.get(nid)
         if flipped:
             out["notes"] = [f"link turned round to the direction the relation allows: {x}" for x in flipped]
+        if type == "claim" and author not in P.curators:
+            fixed = refusals.match_fix(self, author=author, inv=inv, node=nid, statement=body.get("statement", ""),
+                                       op="create")
+            if fixed:
+                out["fixes_refusals"] = fixed
         return out
 
     def _may_revise(self, s: D.Snap, author: str, n: dict) -> bool:
@@ -627,8 +635,10 @@ class Graph:
                 if n["type"] == "claim" and author not in P.curators:
                     problems = claim_issues(s, body, self._support_ids(s, node, []), n["inv"])
                     if problems:
-                        raise GraphError("revision refused:\n- " + "\n- ".join(p.text() for p in problems),
-                                         [p.to_dict() for p in problems])
+                        found = [p.to_dict() for p in problems]
+                        refusals.record_refusal(self, author=author, op="revise", inv=n["inv"], node=node, body=body,
+                                                problems=found)
+                        raise GraphError("revision refused:\n- " + "\n- ".join(p.text() for p in problems), found)
                 at = self.clock()
 
                 def write(con):
@@ -638,7 +648,13 @@ class Graph:
                 self._transaction(write)
             finally:
                 self._after_write()
-        return self.get(node)
+        out = self.get(node)
+        if out["type"] == "claim" and author not in P.curators:
+            fixed = refusals.match_fix(self, author=author, inv=out["inv"], node=node,
+                                       statement=out["body"].get("statement", ""), op="revise")
+            if fixed:
+                out["fixes_refusals"] = fixed
+        return out
 
     def link(self, *, author: str, src: str, rel: str, dst: str, why: str = "", data: dict | None = None) -> dict:
         if rel == "reviews":
@@ -952,6 +968,25 @@ class Graph:
         return {"seq": s.seq, "nodes": len(s.nodes), "edges": len(s.edges), "by_type": dict(by),
                 "leases": len(s.leases)}
 
+    # ── the refusal log (refusals.py) and checking write-ups (report_check.py) ──
+    def refusals(self, inv: str = "", author: str = "", since: str = "", limit: int = 500) -> list[dict]:
+        """Every overclaim the record refused, newest first, with its codes and what fixed it (if anything)."""
+        return refusals.rows(self, inv=inv, author=author, since=since, limit=limit)
+
+    def refusal_report(self, inv: str = "", since: str = "") -> dict:
+        """Overclaims caught per author and per rule, fixed vs open, with the latest in full (and as markdown)."""
+        return refusals.report(self, inv=inv, since=since)
+
+    def verify_refusals(self) -> dict:
+        """The refusal log's own hash chain."""
+        return refusals.verify(self)
+
+    def check_text(self, text: str, inv: str = "") -> dict:
+        """Lint a write-up (markdown) against the record: numbers no result contains, claims stated as settled that
+        the record has as contested / withdrawn / unchecked, codes that don't exist, absolutes nothing counts."""
+        from . import report_check
+        return report_check.check(self, text, inv)
+
     # ── method & coordination (plan.py) ─────────────────────────────
     def next_experiments(self, inv: str, limit: int = 10) -> dict:
         from . import plan

{hypgraph-0.2.0 → hypgraph-0.3.0}/src/hypgraph/language.py

@@ -24,7 +24,7 @@ COMPARATIVE = re.compile(
     r"gains? over|uplift|lift over|advantage over|wins? over|surpass(?:es|ed)?)\b", re.I)
 SIGNIFICANCE = re.compile(r"\b(significant(?:ly)?|statistically|reliably (?:better|worse|higher|lower))\b", re.I)
 CAUSAL = re.compile(
-    r"\b(caus(?:es|ed|ing|al)|cause|leads? to|led to|results? in|resulted in|drives?|driven by|due to|because of|"
+    r"\b(caus(?:es|ed|ing|al)|cause|leads? to|led to|resulted in|drives?|driven by|due to|because of|"
     r"responsible for|is the reason)\b", re.I)
 EXCLUSION = re.compile(
     r"\b(no (?:effect|difference|impact|influence|benefit|improvement|association|relationship)|"

{hypgraph-0.2.0 → hypgraph-0.3.0}/src/hypgraph/mcp.py

@@ -10,7 +10,8 @@ no absolutes without k of n, exclusions need a powered search. A refusal comes b
 fix, which is the point.
 
 Tools: overview · find · show · start_investigation · add · link · revise · withdraw · retract_link · review ·
-next_experiments · work_queue · claim_work · register_run · bound · report · verify · schema.
+next_experiments · work_queue · claim_work · register_run · bound · check_report · refusal_log · report · verify ·
+schema.
 Resources: hypgraph://skill · hypgraph://schema · hypgraph://investigations · hypgraph://investigation/{inv}/report.
 Prompt: method — how to work a question through the record.
 """
@@ -448,6 +449,32 @@ def build(graph: Graph | str, author: Optional[str] = None, files_root: str | No
             raise ToolError("give k (how many times it happened) and n (trials), with 0 <= k <= n")
         return bound_text(k, n, exposure, unit)
 
+    @mcp.tool
+    def check_report(text: str, investigation: str = "") -> str:
+        """Lint a write-up (markdown) against the record BEFORE you hand it over: numbers no result contains, claims
+        stated as settled that the record has as unchecked / contested / withdrawn, codes that don't exist, never /
+        no effect / significantly with nothing behind them. Fix every error; say why for any warning you keep."""
+        try:
+            r = g.check_text(text, g.resolve(investigation) if investigation else "")
+        except (GraphError, KeyError) as e:
+            fail(e)
+        return r["markdown"]
+
+    @mcp.tool
+    def refusal_log(investigation: str = "", author: str = "") -> str:
+        """The overclaims the record refused — per author and rule, fixed or still open. With author: that author's
+        refusals in full, so you can see what you (or a teammate) tried to say and what the record said back."""
+        try:
+            inv = g.resolve(investigation) if investigation else ""
+            if author:
+                rows = g.refusals(inv=inv, author=author.strip().lower())
+                return "\n".join(f"{r['at'][:16]} {', '.join(r['codes'])}: “{r['statement'][:200]}”"
+                                 + (f" → fixed as {r['fixed_by']['node']}" if r["fixed_by"] else " → not fixed")
+                                 for r in rows[:40]) or "No refusals."
+            return g.refusal_report(inv=inv)["markdown"]
+        except (GraphError, KeyError) as e:
+            fail(e)
+
     @mcp.tool
     def schema() -> dict:
         """The node types (fields, which are required), the relations (which types each may join) and the verdicts."""