hypgraph 0.7.12__tar.gz → 0.7.13__tar.gz

{hypgraph-0.7.12 → hypgraph-0.7.13}/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.7.13 — 2026-10-31: verification checks every row, and examples for agent frameworks
+
+- **Verification checks every row, both ways.** A pre-launch audit found that `verify_bundle`, `verify_file` and
+  the browser's `verifyBundle` only checked that each row present matched an event. A bundle or graph file with a
+  withdrawal, a version, a link, a lease or a whole table removed still verified, so a withdrawn claim could come
+  back to life through `load()`; changed authors, times, link ends, reasons and duplicated rows passed too. Now every
+  row must be written by an event and match it field by field, every row an event wrote must be present, and no key
+  may appear twice, in Python, SQLite and the browser alike (`tests/test_verify_complete.py`, which also checks the
+  browser verifier agrees on every case).
+- **Events hash every field of the row they write.** New events carry `reason_sha` (create, revise), `why_sha`
+  (link, retract, withdraw), `note_sha` (leases), a review's `code` and `inv`, and `as` when the importer credits
+  another author. Only the importer may. Older records still verify: what their events don't cover is reported as
+  `unchecked`, field by field, instead of passing silently.
+- **Derived views are checked; standing is labelled.** A bundle's `derived` views must agree with the verified rows
+  on every fact the rows fix (nodes, live links, titles, authors, times, withdrawn or not); an edited view fails.
+  Standing can't be checked from the rows, so the result says `standing: {checked: false}`; `hypgraph verify
+  --standing` re-derives it with the same engine version and fails on a difference. The explorer shows a separate
+  "standing as exported" badge beside the verified one, and a banner over a record that doesn't verify.
+- **The verify page takes a published head** and lists the fields an older record doesn't cover.
+
+- **A LangChain example** (`examples/frameworks/langchain_agent.py`): `create_agent` with the record's tools from a
+  `MultiServerMCPClient` session, the same story as the others. It runs in the `frameworks` CI job.
+- **Examples for agent frameworks** (`examples/frameworks/`): LangGraph, PydanticAI, CrewAI, the OpenAI Agents SDK
+  and the Claude Agent SDK, each connected to a record through `hypgraph mcp`. All five tell the same story: the
+  agent claims a 1.2-point difference is significant, the record refuses with the arithmetic, and the agent writes
+  the honest claim, which is accepted. They run offline with a scripted model through each framework's own
+  tool-calling path, or with `--real` on a real model. The README covers the one setting each framework needs so a
+  refusal reaches the model instead of ending the run. A new CI job runs them all (the Claude Agent SDK, which has no
+  scripted mode, gets a wiring check).
+
 ## 0.7.12 — 2026-10-31: the trust boundary, verification and docs, reviewed before launch
 
 A pre-launch review of who may write as whom, through every interface. Each fix has a test that failed first

{hypgraph-0.7.12 → hypgraph-0.7.13}/NOTICE

@@ -1,5 +1,5 @@
 HypGraph
-Copyright 2026 Nicolas Houghtaling and VoodooMods LLC
+Copyright 2026 VoodooMods LLC
 
 This product is licensed under the Apache License, Version 2.0 (see LICENSE).
 The record format specification and documentation are licensed under CC BY 4.0.

{hypgraph-0.7.12 → hypgraph-0.7.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.12
+Version: 0.7.13
 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/
@@ -180,6 +180,10 @@ the record from its checker until it is returned. The method is in [AGENTS.md](h
 [llms.txt](https://hypgraph.com/llms.txt). What the server enforces, and what it leaves to you, is in
 [SECURITY.md](https://github.com/voodoomods/hypgraph/blob/main/SECURITY.md).
 
+Runnable examples for LangChain, LangGraph, PydanticAI, CrewAI, the OpenAI Agents SDK and the Claude Agent SDK, each
+the same story wired a different way, are in
+[examples/frameworks](https://github.com/voodoomods/hypgraph/tree/main/examples/frameworks).
+
 ## Wire it into your system
 
 The core is one Python package with no dependencies. You decide who is trusted to do what:

{hypgraph-0.7.12 → hypgraph-0.7.13}/README.md

@@ -148,6 +148,10 @@ the record from its checker until it is returned. The method is in [AGENTS.md](h
 [llms.txt](https://hypgraph.com/llms.txt). What the server enforces, and what it leaves to you, is in
 [SECURITY.md](https://github.com/voodoomods/hypgraph/blob/main/SECURITY.md).
 
+Runnable examples for LangChain, LangGraph, PydanticAI, CrewAI, the OpenAI Agents SDK and the Claude Agent SDK, each
+the same story wired a different way, are in
+[examples/frameworks](https://github.com/voodoomods/hypgraph/tree/main/examples/frameworks).
+
 ## Wire it into your system
 
 The core is one Python package with no dependencies. You decide who is trusted to do what:

{hypgraph-0.7.12 → hypgraph-0.7.13}/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.7.12 (2026-10-31)
+## Status at 0.7.13 (2026-10-31)
 
 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.7.12 → hypgraph-0.7.13}/docs/RELEASE-READINESS.md

@@ -4,6 +4,18 @@
 #61 (docs and release engineering). Everything marked as tested was run; the commands are in each PR. Nothing here
 was taken from a changelog without being checked against the code.*
 
+> **Superseded in part (2026-10-31, later the same day).** A second audit found that verification checked rows
+> against events in one direction only: a bundle or graph file with a withdrawal, a version, an edge or a whole
+> table removed still verified, as did changed authors, times, link ends and reasons, and edited derived views. That
+> was a confirmed integrity defect, so the GO below didn't hold for 0.7.12. The fix (exhaustive row checks in the
+> Python, SQLite and browser verifiers, events that hash every row field, derived views checked against the rows,
+> standing reported as not covered) is in the pull request that adds `tests/test_verify_complete.py`, and ships as
+> 0.7.13. The recommendation stands again once that is merged with green CI and released.
+>
+> **Where that stands.** #66 is merged with green CI (17 of 17 checks); on main the suite is 386 passed, and
+> hypswarm, hypmesh and hypdmz pass on it. Released as 0.7.13. The required-checks setting (condition 3 below) is
+> still open, for the operator.
+
 ## Recommendation: CONDITIONAL GO
 
 HypGraph is ready for a public developer preview once #59, #60 and #61 are merged with green CI and released as one

{hypgraph-0.7.12 → hypgraph-0.7.13}/docs/spec.md

@@ -78,19 +78,35 @@ where `prev` is the previous event's hash (64 zeros for the first). Kinds and pa
 
 | kind | ref | payload |
 |---|---|---|
-| `create` | the new node | `{type, code, inv, v: 1, body_sha}`; `body_sha` = sha256 of the version's stored body string |
-| `revise` | the node | `{v, reason, body_sha}` |
-| `review` | the reviewed node | `{review: <review node id>, verdict, on_v, official, body_sha}` |
-| `link` | the edge's source | `{edge, rel, dst, src_v, dst_v, data_sha}`; `data_sha` = sha256 of the stored edge data string |
-| `retract` | the edge's source | `{edge}` |
-| `withdraw` | the node | `{why}` |
-| `lease_take` / `lease_release` | the node | `{task, expires}` |
-
-Any event may carry `task` in its payload: the unit of work that wrote it.
-
-**Verifying** a record means recomputing every hash in order and checking each `prev`. Then check that every stored
-version body and edge matches the `body_sha` / `data_sha` of the event that wrote it, and that no row exists without
-its event.
+| `create` | the new node | `{type, code, inv, v: 1, body_sha, reason_sha, as?}`; `body_sha` = sha256 of the version's stored body string, `reason_sha` of its stored reason |
+| `revise` | the node | `{v, reason, body_sha, reason_sha}`; `reason` is the first 300 characters |
+| `review` | the reviewed node | `{review: <review node id>, verdict, on_v, official, body_sha, code, inv, as?}` |
+| `link` | the edge's source | `{edge, rel, dst, src_v, dst_v, data_sha, why_sha}`; `data_sha` = sha256 of the stored edge data string, `why_sha` of its stored reason |
+| `retract` | the edge's source | `{edge, why_sha}` |
+| `withdraw` | the node | `{why, why_sha, as?}`; `why` is the first 300 characters, `why_sha` covers the stored reason |
+| `lease_take` / `lease_release` | the node | `{task, expires, note_sha, for?}`; `for` = the agent holding the lease when it isn't the actor |
+
+Any event may carry `task` in its payload: the unit of work that wrote it. `as` appears only when the importer
+credits a node or withdrawal to another author; from any other actor it is invalid.
+
+**Verifying** a record means recomputing every hash in order and checking each `prev`, then checking the rows
+against the events **both ways**: every row was written by an event and matches it field by field, every row an
+event wrote is present, and no key appears twice. The fields each event fixes:
+
+| table | key | must equal |
+|---|---|---|
+| `nodes` | `create.ref`, `review.payload.review` | `type`, `code`, `inv` from the payload (a review: type `review`); `created_at` = the event's `at`; `created_by` = the actor, or `as` |
+| `versions` | node + `v` | `at`, `by` = the actor, sha256 of `body` = `body_sha`, sha256 of `reason` = `reason_sha` (a review's: empty) |
+| `edges` | `payload.edge` | `src` = ref, `rel`, `dst`, `src_v`, `dst_v`, `at`, `by` = the actor, sha256 of `data` = `data_sha`, of `why` = `why_sha` |
+| `withdrawals` | the node | `at`, `by` = the actor or `as`, sha256 of `why` = `why_sha` |
+| `retractions` | `payload.edge` | `at`, `by` = the actor, sha256 of `why` = `why_sha` |
+| `leases` | in id order, one per lease event in order | `node` = ref, `agent` = `for` or the actor, `task`, `kind` (`take` / `release`), `at`, `expires`, sha256 of `note` = `note_sha` |
+
+Records written before these fields existed (before 0.7.13) carry events without `reason_sha`, `why_sha`,
+`note_sha`, `as`, or a review's `code` and `inv`. A verifier checks what those events do carry (a revision's or a
+withdrawal's first 300 characters, a lease note given in full, a review's investigation from its target) and
+reports every other non-empty field as **not covered**, by table and field, rather than passing it silently. Without
+`as`, a row the importer wrote may credit any author; that is reported too.
 
 ## 4. Bundles — `hypgraph/1-bundle`
 
@@ -108,7 +124,7 @@ strings and compares.
  "versions": [{"node": "…", "v": 1, "at": "…", "by": "…", "reason": "", "body": "<stored canonical string>"}],
  "edges": [{"id": 1, "src": "…", "src_v": 1, "rel": "…", "dst": "…", "dst_v": 1, "data": "<stored string>", "…": "…"}],
  "withdrawals": [], "retractions": [], "leases": [],
- "derived": {"…": "standing at export time, for viewers; never trusted by a verifier"}}
+ "derived": {"…": "views for viewers; their facts are checked against the rows, their standing is not"}}
 ```
 
 A **scoped** bundle (one investigation out of a shared record) replaces events outside it with
@@ -123,6 +139,14 @@ or a prefix of at least 16 hex characters) fails unless the chain ends there: `h
 `verify_bundle(b, head=HEX)`. A bundle without a `head` field is checked for consistency only. How a head is
 published and signed, and what each check does and doesn't show: [verification.md](verification.md).
 
+**Derived views.** `derived` is a convenience for viewers, and a viewer shows it beside a verified chain, so a
+verifier must check every fact in it that the rows fix: which investigations it covers (the scope's, or every
+investigation node), which nodes each investigation's graph shows (all of them, unless capped at 5,000) and which
+live (unretracted) links among them, each node's `type`, `code`, `inv`, `by`, `at`, `v`, `title` and `kind`, whether
+it is shown as withdrawn, and each link's fields. **Standing** (review state, support, at-risk, the sentence) can't
+be checked from the rows alone: it is what the exporting engine derived. A verifier reports it as not checked, or
+re-derives it with the same engine version (`hypgraph verify FILE --standing`) and compares.
+
 ## 5. Derived standing (normative)
 
 Implementations must derive these, never store them:

{hypgraph-0.7.12 → hypgraph-0.7.13}/docs/verification.md

@@ -8,7 +8,7 @@ somewhere its keeper can't change.
 
 | | What it shows | How | What it doesn't show |
 |---|---|---|---|
-| **1. Internal consistency** | The chain of events is unbroken, and every node, version, link, withdrawal and retraction matches the event that wrote it. | `hypgraph verify study.bundle.json` (or a graph file), `verify_bundle(b)` in Python, `HypGraph.verifyBundle` in the browser | That it wasn't rewritten. Whoever can write the record can change it, recompute every hash, or cut it short, and it still verifies. |
+| **1. Internal consistency** | The chain of events is unbroken; every node, version, link, withdrawal, retraction and lease was written by an event and matches it field by field; no row an event wrote is missing; and the facts a viewer shows beside it (which nodes and links, titles, authors, times, withdrawn or not) agree with those rows. | `hypgraph verify study.bundle.json` (or a graph file), `verify_bundle(b)` in Python, `HypGraph.verifyBundle` in the browser | That it wasn't rewritten. Whoever can write the record can change it, recompute every hash, or cut it short, and it still verifies. |
 | **2. Not rewritten since it was published** | The record ends at the head that was published. Any change to anything before it, or a record cut short, ends somewhere else. | `hypgraph verify study.bundle.json --head <published head>`, `verify_bundle(b, head=...)`, `anchored(g.verify(), head)` | Who published that head. That's the job of where it was published (below). |
 | **3. Provenance of the evidence** | Who recorded what, and how: a lab-recorded run (only the instrument author files those) or an agent's report, its inputs and outputs by hash, which lines of support are independent. | The record's derived standing: `hypgraph show CL1 --why`, the report | That the instrument's own files are honest. A host decides who the instrument is (the policy). |
 | **4. That a claim is true** | Nothing. | Reviews, replications, separate implementations, new data: the evidence the record keeps and ranks | — |
@@ -24,11 +24,12 @@ claims in it stand exactly as well as the record derives, and no better.
 $ hypgraph demo && hypgraph export -o study.bundle.json
 Wrote study.bundle.json: 59 events, 24 nodes
 $ hypgraph verify study.bundle.json
-✓ study.bundle.json: 59 events verified — chain intact, every row matches the event that wrote it.
+✓ study.bundle.json: 59 events verified — chain intact, every row matches the event that wrote it, and none is missing.
   head 565123f3a7ac06ed18ab555935fde0457ebb6a302dc188fc83dbf36af579623f
   consistent with itself; to rule out a rewrite, check it against a published head (--head)
+  standing not checked: standing (review state, support, at-risk, the sentence) is what the exporting engine derived: …
 $ hypgraph verify study.bundle.json --head 565123f3a7ac06ed
-✓ study.bundle.json: 59 events verified — chain intact, every row matches the event that wrote it.
+✓ study.bundle.json: 59 events verified — chain intact, every row matches the event that wrote it, and none is missing.
   head 565123f3a7ac06ed18ab555935fde0457ebb6a302dc188fc83dbf36af579623f
   matches the anchored head: not rewritten or cut short since it was published
 ```
@@ -67,6 +68,18 @@ SHA-256 over strings and compares: no JSON canonicalisation to reimplement. The
 and the verifier's rules, is in [spec.md](spec.md). The site checks bundles in the browser with WebCrypto, from a
 separate implementation.
 
+## Standing, and older records
+
+- **Standing** (review state, support, at-risk, the one-line summary) is derived, and a bundle carries the standing
+  its exporter derived. The chain doesn't cover it. `hypgraph verify study.bundle.json --standing` replays the
+  verified rows and derives it again; it fails if the result differs. Standing rules change between releases, so it
+  only compares a bundle exported by the same version, and says so otherwise. A graph file has no stored standing:
+  it is derived on every read.
+- **Records written before 0.7.13** have events that don't hash a few row fields (a link's reason, a retraction's
+  reason, a lease note, a revision's full reason, the credited author of an importer's node). The verifier checks
+  what those events carry and lists the rest as *not covered*, with a count per field. Rewriting one of those fields
+  in an old record isn't caught; new writes cover them all.
+
 ## Scoped bundles and references
 
 - `hypgraph export --inv INV` writes one investigation. Events outside it are redacted to their hash, so the chain
@@ -79,5 +92,7 @@ separate implementation.
 
 `dev/e2e_install.py` installs HypGraph into a fresh environment and walks the whole path: a record, a claim accepted
 and one refused, a review, an export, and verification in another directory with no graph file, on its own and
-against the head, and failing on an edited copy. `tests/test_anchoring.py` rewrites a record (changing a claim and
+against the head, and failing on an edited copy. `tests/test_verify_complete.py` drops, duplicates, empties and
+edits every table and every field of a bundle and of a graph file, and edits the derived views: each one fails, in
+Python and in the browser verifier alike. `tests/test_anchoring.py` rewrites a record (changing a claim and
 recomputing every hash) and cuts one short: both verify on their own, and both fail against the published head.

hypgraph-0.7.13/examples/frameworks/README.md

@@ -0,0 +1,70 @@
+# HypGraph with agent frameworks
+
+One story, told once per framework, so the difference between the files is only the wiring.
+
+An eval harness has compared two models on the same 1,000 held-out questions: model A got 812 right, model B 800.
+An agent, connected to the record over MCP as the author `analyst`, is asked whether A is more accurate. It writes
+"significantly more accurate". The record refuses that with the arithmetic (p ≈ 0.5) and says what to write instead.
+The agent writes the honest claim, and it is accepted. Afterwards the script reads the record in Python and prints
+what was refused, what was accepted, and the refusal log.
+
+The framework doesn't need to know HypGraph exists. It sees MCP tools, and the record does the checking.
+
+| Framework | File | Install | MCP wiring |
+|---|---|---|---|
+| LangChain | [langchain_agent.py](langchain_agent.py) | `langchain langchain-mcp-adapters` | `MultiServerMCPClient` session → `create_agent` |
+| LangGraph | [langgraph_agent.py](langgraph_agent.py) | `langgraph langchain-mcp-adapters` | `load_mcp_tools(session)` into a `ToolNode` |
+| PydanticAI | [pydantic_ai_agent.py](pydantic_ai_agent.py) | `"pydantic-ai-slim[mcp]"` | `MCPToolset(StdioTransport(...))` |
+| CrewAI | [crewai_agent.py](crewai_agent.py) | `crewai` | `Agent(mcps=[MCPServerStdio(...)])` |
+| OpenAI Agents SDK | [openai_agents_sdk.py](openai_agents_sdk.py) | `openai-agents` | `Agent(mcp_servers=[MCPServerStdio(...)])` |
+| Claude Agent SDK | [claude_sdk_agent.py](claude_sdk_agent.py) | `claude-agent-sdk` | `ClaudeAgentOptions(mcp_servers={...})` |
+
+Every example also needs `pip install "hypgraph[mcp]"`. [_story.py](_story.py) holds what they share: the record
+before the agent arrives, the task, the server command, and the check at the end.
+
+## Run them
+
+```bash
+cd examples/frameworks
+python langgraph_agent.py                          # scripted model: offline, free, the same every time
+python langgraph_agent.py --real --model gpt-4.1-mini
+```
+
+With no flags, a scripted model plays a careful agent's moves through the framework's own tool-calling path:
+read the overview, overclaim, read the refusal, write the honest claim. That shows the wiring works, including the
+part that matters most, a refused write getting back to the model. It can't show a model reasoning. `--real` uses a
+real model (`OPENAI_API_KEY`, or whatever the framework's model string needs; `--model` or `MODEL` picks it). A real
+model passes if it got a claim accepted and fixed every refusal, because a careful model may write the honest claim
+the first time.
+
+`--db FILE` keeps the record, so you can open it afterwards with `hypgraph --db FILE serve`.
+
+The Claude Agent SDK drives Claude Code itself and has no scripted mode. `python claude_sdk_agent.py` is a real run
+(Claude Code signed in, or `ANTHROPIC_API_KEY`; `--model` takes `haiku`, `sonnet` or `opus`). `--check` starts the
+record's server from the exact options the SDK would use and confirms every allowed tool exists. That needs no model.
+
+## What to copy
+
+- **One server per author.** `hypgraph --db FILE --as analyst mcp` writes as `analyst` and nothing else. The agent
+  can't pass another name, and its verdicts count only if the investigation names it as a reviewer. Give each agent
+  in a team its own server, with its own author.
+- **Let a refusal reach the model.** A refused write is an MCP tool error whose text names the problem and the fix
+  (for example `[SIGNIFICANCE_NOT_SHOWN]`). If the framework ends the run on a tool error, the agent never sees it:
+  - LangChain: `load_mcp_tools(session, handle_tool_errors=True)`, the adapter's default, returns it as the tool's
+    output, so `create_agent` needs nothing more. Hold one `client.session(...)` for the run: `client.get_tools()`
+    alone starts a server process for every tool call.
+  - LangGraph: `ToolNode(tools, handle_tool_errors=True)`.
+  - PydanticAI: the default (`tool_error_behavior="retry"`) sends it back as a retry prompt. `max_retries` bounds it.
+  - CrewAI and the OpenAI Agents SDK hand it back as the tool's output by default.
+  - Claude Code shows tool errors to the model.
+- **Keep the agent on the record.** The Claude example passes `tools=[]` (no shell, no file edits),
+  `strict_mcp_config=True` (no other MCP servers) and pre-approves only the record's tools.
+- **CrewAI names MCP tools after the command line** (`<command>_<args>_<tool>`, hashed past 64 characters). The
+  example runs plain `hypgraph mcp` with `HYPGRAPH_DB` and `HYPGRAPH_AUTHOR` in its environment, so the tools come out
+  as `hypgraph_mcp_add` and so on.
+
+Frameworks that take plain Python functions as tools can skip MCP. Call `Graph` directly and return the refusal text
+from `GraphError`; see [hypgraph.com/engineers](https://hypgraph.com/engineers/#connect).
+
+Tested with langchain 1.4, langgraph 1.2, pydantic-ai 2.x, crewai 1.15, openai-agents 0.20 and claude-agent-sdk 0.2 (the scripted
+runs, and the Claude `--check`, run in CI).

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

{hypgraph-0.7.12 → hypgraph-0.7.13}/src/hypgraph/bundle.py

@@ -11,7 +11,8 @@ SHA-256 over strings plus a few lookups — any language can do it (the site doe
      "versions": [{"node", "v", "at", "by", "reason", "body"}],   # body = the stored canonical string
      "edges":    [{"id", "src", "src_v", "rel", "dst", "dst_v", "data", "at", "by", "why"}],   # data likewise
      "withdrawals": [...], "retractions": [...], "leases": [...],
-     "derived":  {...},                                     # standing at export time, for viewers; never trusted
+     "derived":  {...},                                     # views for viewers: facts checked against the rows,
+                                                            # standing not (verify_bundle(..., standing=True) re-derives)
      "telemetry": {"source", "covered_by_chain": false, "events": [...]}}   # optional: a swarm's telemetry sidecar
 
 A scoped bundle (one investigation out of a shared graph) redacts the events outside it to {seq, hash, prev}: their
@@ -33,7 +34,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from . import __version__
-from .store import GENESIS, event_body, now
+from .store import GENESIS, ROW_TABLES, check_rows, event_body, now
 
 if TYPE_CHECKING:
     from .graph import Graph
@@ -132,6 +133,7 @@ def derive_views(g: "Graph", invs: list[str]) -> dict:
                               "profile": profiles.view(pid), "stages": g.stages(i), "completion": g.completion(i),
                               "board": g.question_board(i), "orders": g.orders(i)}
     views["verify"] = g.verify()
+    views["at"] = g.clock()          # the time standing was derived at (leases expire): re-deriving uses it
     return views
 
 
@@ -153,18 +155,32 @@ def anchored(res: dict, head: str) -> dict:
     return {**res, "anchored": True}
 
 
-def verify_bundle(b: dict, head: str = "") -> dict:
-    """Check a bundle string-for-string: the chain, then every row against the event that wrote it. With ``head``,
-    also that the chain ends at that published head (see ``anchored``)."""
-    return anchored(_verify_bundle(b), head)
+def verify_bundle(b: dict, head: str = "", *, standing: bool = False) -> dict:
+    """Check a bundle string-for-string: the chain; then the rows against the events, both ways (every row written by
+    an event, every event's row present, every recorded field equal); then the derived views against those rows. With
+    ``head``, also that the chain ends at that published head (see ``anchored``). With ``standing``, re-derive the
+    standing from the verified rows and compare it with what the bundle carries (``rederive``)."""
+    res = anchored(_verify_bundle(b), head)
+    if standing and res.get("ok"):
+        res = {**res, "standing": rederive(b)}
+        if res["standing"].get("problem"):
+            res = {**res, "ok": False, "problem": res["standing"]["problem"]}
+    return res
+
+
+STANDING_NOTE = ("standing (review state, support, at-risk, the sentence) is what the exporting engine derived: the "
+                 "chain doesn't cover it. Re-derive it from the verified rows with `hypgraph verify --standing`.")
 
 
 def _verify_bundle(b: dict) -> dict:
     if not isinstance(b, dict) or b.get("format") != BUNDLE_FORMAT:
         return {"ok": False, "problem": f"not a {BUNDLE_FORMAT} bundle"}
-    prev, checked, red = GENESIS, 0, 0
-    creates, revs, reviews, links, withdraws, retracts = {}, {}, {}, {}, set(), set()
+    prev, checked, red, seqs = GENESIS, 0, 0, set()
+    events: list[dict] = []
     for ev in sorted(b.get("events") or [], key=lambda e: e["seq"]):
+        if ev["seq"] in seqs:
+            return {"ok": False, "broken_at": ev["seq"], "problem": "two events share a sequence number"}
+        seqs.add(ev["seq"])
         if ev.get("redacted"):
             if ev.get("prev") != prev:
                 return {"ok": False, "broken_at": ev["seq"], "problem": "chain broken (redacted event)"}
@@ -176,51 +192,19 @@ def _verify_bundle(b: dict) -> dict:
         if body.get("prev") != prev:
             return {"ok": False, "broken_at": ev["seq"], "problem": "chain broken (prev does not match)"}
         prev, checked = ev["hash"], checked + 1
-        k, ref, p = body["kind"], body["ref"], body["payload"]
-        if k == "create":
-            creates[ref] = p
-            revs[(ref, int(p.get("v", 1)))] = p.get("body_sha")
-        elif k == "revise":
-            revs[(ref, int(p.get("v")))] = p.get("body_sha")
-        elif k == "review":
-            reviews[p["review"]] = p
-            revs[(p["review"], 1)] = p.get("body_sha")
-        elif k == "link":
-            links[int(p["edge"])] = p
-        elif k == "withdraw":
-            withdraws.add(ref)
-        elif k == "retract":
-            retracts.add(int(p["edge"]))
+        events.append(body)
     if b.get("head") and b["head"] != prev:
         return {"ok": False, "problem": "the chain does not end at the bundle's head"}
-    for n in b.get("nodes") or []:
-        c = creates.get(n["id"])
-        if n["type"] == "review":
-            if n["id"] not in reviews:
-                return {"ok": False, "problem": f"review {n['id']} has no event"}
-        elif not c or (c.get("type"), c.get("code"), c.get("inv")) != (n["type"], n["code"], n["inv"]):
-            return {"ok": False, "problem": f"node {n['id']} differs from its create event"}
-    for v in b.get("versions") or []:
-        want = revs.get((v["node"], v["v"]))
-        if want is None:
-            return {"ok": False, "problem": f"version {v['node']} v{v['v']} has no event"}
-        if _sha(v["body"]) != want:
-            return {"ok": False, "problem": f"version {v['node']} v{v['v']} differs from its event"}
-    for e in b.get("edges") or []:
-        want = links.get(e["id"])
-        if want is None:
-            return {"ok": False, "problem": f"edge {e['id']} has no event"}
-        if (want.get("rel"), want.get("dst"), want.get("dst_v")) != (e["rel"], e["dst"], e["dst_v"]) or \
-                _sha(e["data"]) != want.get("data_sha"):
-            return {"ok": False, "problem": f"edge {e['id']} differs from its event"}
-    for w in b.get("withdrawals") or []:
-        if w["node"] not in withdraws:
-            return {"ok": False, "problem": f"withdrawal of {w['node']} has no event"}
-    for r in b.get("retractions") or []:
-        if int(r["edge"]) not in retracts:
-            return {"ok": False, "problem": f"retraction of edge {r['edge']} has no event"}
+    tables = {t: b.get(t) or [] for t in ROW_TABLES}
+    rows = check_rows(events, tables, importer=str((b.get("policy") or {}).get("importer") or "importer"))
+    if "problem" in rows:
+        return {"ok": False, "problem": rows["problem"]}
+    problem = _derived_problem(b, tables)
+    if problem:
+        return {"ok": False, "problem": f"the derived views contradict the verified record: {problem}"}
     out = {"ok": True, "checked": checked, "head": prev, "complete": red == 0, "redacted": red,
-           "nodes": len(b.get("nodes") or []), "edges": len(b.get("edges") or [])}
+           "nodes": len(tables["nodes"]), "edges": len(tables["edges"]), "unchecked": rows["unchecked"],
+           "standing": {"checked": False, "note": STANDING_NOTE}}
     if red:
         out["warning"] = (f"{red} event(s) outside this investigation are redacted: their content can't be checked, so "
                           "a change hidden among them (a withdrawal, say) would not show. The full record rules that "
@@ -228,6 +212,119 @@ def _verify_bundle(b: dict) -> dict:
     return out
 
 
+def _j(v: Any) -> str:
+    """A value in a problem, written as the browser's verifier writes it (JSON.stringify)."""
+    return json.dumps(v, ensure_ascii=False, separators=(",", ":"))
+
+
+def _title(body: dict) -> str:
+    """A node's title as the engine shows it (Graph.brief)."""
+    t = (body.get("statement") or body.get("title") or body.get("text") or body.get("aim") or body.get("summary")
+         or body.get("choice") or body.get("citation") or body.get("name") or body.get("path") or body.get("verdict")
+         or "")
+    return str(t)[:300]
+
+
+def _derived_problem(b: dict, tables: dict) -> str:
+    """The derived views are presentation, but a viewer shows them beside a verified chain: every fact in them that
+    the rows fix — which nodes and live links each investigation has, each node's type, code, author, time, version,
+    title and whether it is withdrawn — must agree with the verified rows. Standing can't be checked this way."""
+    d = b.get("derived")
+    if d is None:
+        return ""
+    if not isinstance(d, dict):
+        return "derived is not an object"
+    nodes = {n["id"]: n for n in tables["nodes"]}
+    latest: dict[str, tuple[int, dict]] = {}
+    for v in tables["versions"]:
+        if v["v"] > latest.get(v["node"], (0, {}))[0]:
+            latest[v["node"]] = (v["v"], json.loads(v["body"]))
+    withdrawn = {w["node"] for w in tables["withdrawals"]}
+    retracted = {int(r["edge"]) for r in tables["retractions"]}
+    live = {int(e["id"]): e for e in tables["edges"] if int(e["id"]) not in retracted}
+    scope = str((b.get("scope") or {}).get("inv") or "")
+    invs = {scope} if scope else {i for i, n in nodes.items() if n["type"] == "investigation"}
+
+    def facts(x: dict, where: str) -> str:
+        n = nodes.get(x.get("id")) if isinstance(x, dict) else None
+        if not n:
+            return f"{where} shows {x.get('id') if isinstance(x, dict) else _j(x)}, which the record doesn't hold"
+        v, body = latest.get(n["id"], (0, {}))
+        want = {"type": n["type"], "code": n["code"], "inv": n["inv"], "by": n["created_by"], "at": n["created_at"],
+                "v": v, "title": _title(body), "kind": body.get("kind") or body.get("verdict") or ""}
+        for k, w in want.items():
+            if k in x and x[k] != w:
+                return f"{where} shows {n['code'] or n['id']} with {k} {_j(x[k])}; the record has {_j(w)}"
+        life = (x.get("state") or {}).get("lifecycle")
+        if life is not None and (life == "withdrawn") != (n["id"] in withdrawn):
+            return (f"{where} shows {n['code'] or n['id']} as {life}; the record "
+                    f"{'withdrew it' if n['id'] in withdrawn else 'has no withdrawal of it'}")
+        return ""
+    by_inv = d.get("by_inv") or {}
+    if set(by_inv) != invs:
+        return "the views don't cover the record's investigations"
+    for x in d.get("investigations") or []:
+        if x.get("id") not in invs:
+            return f"the investigation list shows {x.get('id')}, which isn't in the bundle's scope"
+        p = facts(x, "the investigation list")
+        if p:
+            return p
+    for inv, v in by_inv.items():
+        sg = (v or {}).get("subgraph") or {}
+        shown = sg.get("nodes") or []
+        for x in shown:
+            p = facts(x, f"the graph of {nodes[inv]['code'] or inv}")
+            if p:
+                return p
+        mine = {i for i, n in nodes.items() if n["inv"] == inv or i == inv}
+        ids = [x["id"] for x in shown]
+        if len(ids) != len(set(ids)) or (set(ids) != mine and not (len(mine) > len(ids) >= 5000)):
+            return f"the graph of {nodes[inv]['code'] or inv} doesn't show the nodes the record holds"
+        want = {i: e for i, e in live.items() if e["src"] in set(ids) and e["dst"] in set(ids)}
+        got = sg.get("edges") or []
+        if len(got) != len(want) or {int(e["id"]) for e in got} != set(want):
+            return f"the graph of {nodes[inv]['code'] or inv} doesn't show the live links the record holds"
+        for e in got:
+            r = want[int(e["id"])]
+            for k in ("src", "src_v", "rel", "dst", "dst_v", "at", "by", "why"):
+                if k in e and e[k] != r[k]:
+                    return f"the graph shows link {e['id']} with {k} {_j(e[k])}; the record has {_j(r[k])}"
+            if "data" in e and e["data"] != json.loads(r["data"]):      # as values: 1.0 and 1 are one number
+                return f"the graph shows link {e['id']} with other data than the record"
+    return ""
+
+
+def rederive(b: dict) -> dict:
+    """Replay a complete bundle in memory and derive the standing again, at the time it was derived, with this
+    engine: {"checked": True} when it matches what the bundle carries, a "problem" when it doesn't. Standing rules
+    change between releases, so only a bundle exported by this version can be compared; others are reported as not
+    checked."""
+    from .graph import Graph
+    from .policy import Policy
+    d = b.get("derived")
+    if not isinstance(d, dict):
+        return {"checked": False, "note": "the bundle carries no derived views"}
+    if b.get("generator") != f"hypgraph {__version__}":
+        return {"checked": False, "note": f"exported by {b.get('generator') or 'an unknown version'}; standing rules "
+                                          f"differ between releases, so re-derive it with that version"}
+    if b.get("redacted_events") or any(e.get("redacted") for e in b.get("events") or []):
+        return {"checked": False, "note": "a scoped bundle can't be replayed; re-derive from the full record"}
+    at = str(d.get("at") or b.get("exported_at") or now())
+    g = Graph(None, policy=Policy.from_dict(b.get("policy") or {}), clock=lambda: at)
+    load(g, b)
+    fresh = json.loads(json.dumps(derive_views(g, list(d.get("by_inv") or {})), sort_keys=True))
+    old = json.loads(json.dumps(d, sort_keys=True))
+    for k in ("investigations", "by_inv"):
+        if fresh.get(k) != old.get(k):
+            where = k
+            if k == "by_inv":
+                where = next((f"{i}/{view}" for i in old.get(k) or {} for view in (old[k][i] or {})
+                              if (fresh[k].get(i) or {}).get(view) != old[k][i][view]), k)
+            return {"checked": False, "problem": f"the standing the bundle carries differs from what its record "
+                                                 f"derives ({where})"}
+    return {"checked": True}
+
+
 def load(g: "Graph", b: dict) -> None:
     """Replay a complete bundle into an empty graph, row for row — the result verifies exactly as the original."""
     v = verify_bundle(b)

{hypgraph-0.7.12 → hypgraph-0.7.13}/src/hypgraph/cli.py

@@ -276,15 +276,24 @@ def cmd_report(args) -> int:
 def cmd_verify(args) -> int:
     target = args.target or args.db
     if str(target).endswith(".json"):
-        res = verify_bundle(json.loads(Path(target).read_text(encoding="utf-8")), head=args.head)
+        res = verify_bundle(json.loads(Path(target).read_text(encoding="utf-8")), head=args.head,
+                            standing=args.standing)
     else:
         res = anchored(verify_file(target), args.head)
     ok = res.get("ok")
     text = (f"✓ {target}: {res.get('checked')} events verified — chain intact, every row matches the event that "
-            f"wrote it.\n  head {res.get('head', '')}" if ok else f"✗ {target}: {res.get('problem')}")
+            f"wrote it, and none is missing.\n  head {res.get('head', '')}" if ok else f"✗ {target}: {res.get('problem')}")
     if ok:
         text += ("\n  matches the anchored head: not rewritten or cut short since it was published" if res.get("anchored")
                  else "\n  consistent with itself; to rule out a rewrite, check it against a published head (--head)")
+    if ok and res.get("unchecked"):
+        text += ("\n  not covered (written before events hashed these fields): "
+                 + ", ".join(f"{f} ×{n}" for f, n in sorted(res["unchecked"].items())))
+    st = res.get("standing") or {}
+    if ok and st.get("checked"):
+        text += "\n  standing re-derived from the verified rows: it matches what the bundle carries"
+    elif ok and st:
+        text += "\n  standing not checked: " + str(st.get("note") or "")
     if res.get("warning"):
         text += "\n  note: " + res["warning"]
     _out(args, res, text)
@@ -510,6 +519,8 @@ def build_parser() -> argparse.ArgumentParser:
     s.add_argument("target", nargs="?", default="")
     s.add_argument("--head", default="", help="the head published for this record (or its first 16+ hex characters): "
                                               "fail unless the chain ends there")
+    s.add_argument("--standing", action="store_true", help="bundles: re-derive the standing from the verified rows and "
+                                                           "fail if it differs from what the bundle carries")
     s = cmd("export", cmd_export, "write a verifiable bundle")
     s.add_argument("--inv", default="", help="one investigation (events outside it are redacted)")
     s.add_argument("-o", "--output", default="")