hypgraph 0.7.8__tar.gz → 0.7.10__tar.gz

{hypgraph-0.7.8 → hypgraph-0.7.10}/AGENTS.md

@@ -3,6 +3,8 @@
 You are an AI agent and you've been pointed at HypGraph. This page is for you; https://hypgraph.com/llms.txt is the
 same in short.
 
+**What standing is not.** Standing is derived from what was written, by the record's rules: never present it as a certification, a peer review or advice (https://hypgraph.com/disclaimer/).
+
 **What it is.** A research record you write into and can't flatter. You add questions, hypotheses, experiments, runs,
 results, claims, sources, reviews and decisions. You can't set how well anything is known: review state, risk,
 independent support and evidence strength are worked out from the record each time it's read. Every write is a

{hypgraph-0.7.8 → hypgraph-0.7.10}/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 0.7.10 — 2026-10-30: fixes from the first live blind run
+
+Claude led a question on a HypMesh and issued a blind order; Codex took the order through its seat and counted the
+primes below 1,000,000 whose digits sum to 23 with its own sieve. The record marked its result written blind and
+agreeing blind with Claude's, and nothing sealed reached Codex. Four fixes from that run and a phone-width check:
+
+- **Investigations are part of the problem statement a blind checker reads.** Only the order's own investigation
+  and the curators' were. A lead whose framing lived in a second investigation had it sealed, the numbers that
+  define the problem (1,000,000; 23) read as secrets, and an honest blind order was refused. Questions and
+  investigations say what is being found out; don't put answers in them.
+- **`my_work` without an investigation lists your orders in every investigation.** It asked "which
+  investigation?" when a record held two, and the seat's first call failed.
+- **`produced_by`, `generated_by`, `output_of`, `executed_by` and `tested_by` are read as the relation they
+  invert.** The node types fix the direction, so the link is turned round. Codex's first result was refused for
+  `produced_by`.
+- **On a phone, every tab of the embedded app can be reached.** The embed's `overflow: visible` beat the narrow
+  rule that makes the nav a scrolling strip. On hypdmz.com at 375 px, four of the eight tabs (Evidence, Work
+  orders, Audit log, Report) sat past the edge with no way to scroll to them. The nav now scrolls, and the embed
+  clips sideways, so the closed drawer can't widen a host page that doesn't clip it.
+
+## 0.7.9 — 2026-10-30: blind work orders
+
+- **A checker can measure without seeing the answer it checks.** `issue_work(..., blind=True)` (MCP `issue_work`
+  `blind=true`, HTTP write `blind`) issues a work order whose assignee works blind until it returns the order.
+  The order text gives the objective, the method and the target by code only. Hypotheses and their predictions,
+  results, claims, reviews, runs and their code, sources, other orders and other teams' attempts are sealed.
+  `hypgraph.blind` holds the rules:
+  - **At issue**, a blind order is refused with a prediction, with a predicate that has to read its target
+    (`reviewed`, `no_open_objection`, `report_clean`), for an assignee that has already written in the record, and
+    when its objective, method or note quote a number only the sealed material carries.
+  - **At read**, the MCP server seals its seat while that seat holds an open blind order. The tools that summarise
+    what others wrote are refused, `show` refuses a sealed node, `find` leaves sealed nodes out, and every number
+    only the sealed material carries is scrubbed from what comes back. `blind.dispatch(g, ..., keep=)` gives a host
+    the same redaction for its HTTP routes, per reader (HypMesh uses it). `hypgraph serve` and the Python API read
+    the whole record: a file is only as blind as whoever holds it.
+  - **In standing**, a result its assignee wrote inside the window is `blind` (and `sealed` while the window is
+    open). After the return, a blind result that repeats an earlier result's numbers `agrees_blind` with it
+    instead of restating it, and a claim or hypothesis counts its `blind_lines`: "2 independent lines of support
+    (1 written blind)". A result revised after the window closed is no longer blind.
+  - The record sees writes, not reads. A seat that read the record before its order was issued has already seen
+    what is now sealed: give a checker its order first.
+
 ## 0.7.8 — 2026-10-29: pinned references between records
 
 - **A record can cite a node of another record and prove what it read.** A `source` takes four more fields,

hypgraph-0.7.10/DISCLAIMER.md

@@ -0,0 +1,36 @@
+# Disclaimer
+
+## Provided as is
+
+HypGraph is provided **as is, without warranty of any kind**, under the
+[Apache License 2.0](https://github.com/voodoomods/hypgraph/blob/main/LICENSE). Sections 7 and 8 of that licence
+(Disclaimer of Warranty, Limitation of Liability) apply to the code, the record format, the documentation, the
+examples and the website.
+
+## Standing is derived, not certified
+
+A record's standing (checked, verified, replicated, contested, at risk,
+stale) is worked out from what was written into it, by rules you can read in the
+[spec](https://hypgraph.com/spec/) and the code. It is not a certification, a peer review, an audit, or an
+endorsement by VoodooMods LLC. The rules catch some ways a record can overclaim; they cannot catch a measurement that
+was wrong when it was taken, a source that misreports, or a review done carelessly.
+
+## A verified chain proves integrity, not truth
+
+`hypgraph verify` shows that a record or bundle has not been
+changed since it was written. It does not show that what was written is correct.
+
+## Not advice
+
+Nothing in a record, report, profile or example is legal, medical, financial or investment advice.
+The trading profile and its examples work on paper positions and historical data; past results do not predict
+future ones.
+
+## Your records are yours to answer for
+
+You decide what goes into a record and what you do with what comes out,
+including when you share a bundle or a report. Records are append-only: a withdrawal is written, not deleted, so do
+not put anything into a record that you would need to erase.
+
+HypGraph is made by VoodooMods LLC. Questions: open an issue at
+https://github.com/voodoomods/hypgraph/issues.

{hypgraph-0.7.8 → hypgraph-0.7.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.8
+Version: 0.7.10
 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/
@@ -245,6 +245,12 @@ affect, and a randomized suite checks that against a full rebuild. Run `python d
 
 HypGraph is made by **Nicolas Houghtaling** at **[VoodooMods LLC](https://github.com/voodoomods)**.
 
+## Disclaimer
+
+Provided as is, without warranty. Standing is derived from what was written into a record, by rules you can
+read; it is not a certification or an endorsement, a verified chain proves a record unchanged rather than correct, and
+nothing here is legal, medical or financial advice. The full text: [DISCLAIMER.md](https://github.com/voodoomods/hypgraph/blob/main/DISCLAIMER.md).
+
 ## License
 
 Code: [Apache-2.0](https://github.com/voodoomods/hypgraph/blob/main/LICENSE). The record format ([docs/spec.md](https://github.com/voodoomods/hypgraph/blob/main/docs/spec.md)) and the docs: CC BY 4.0. Cite it with

{hypgraph-0.7.8 → hypgraph-0.7.10}/README.md

@@ -213,6 +213,12 @@ affect, and a randomized suite checks that against a full rebuild. Run `python d
 
 HypGraph is made by **Nicolas Houghtaling** at **[VoodooMods LLC](https://github.com/voodoomods)**.
 
+## Disclaimer
+
+Provided as is, without warranty. Standing is derived from what was written into a record, by rules you can
+read; it is not a certification or an endorsement, a verified chain proves a record unchanged rather than correct, and
+nothing here is legal, medical or financial advice. The full text: [DISCLAIMER.md](https://github.com/voodoomods/hypgraph/blob/main/DISCLAIMER.md).
+
 ## License
 
 Code: [Apache-2.0](https://github.com/voodoomods/hypgraph/blob/main/LICENSE). The record format ([docs/spec.md](https://github.com/voodoomods/hypgraph/blob/main/docs/spec.md)) and the docs: CC BY 4.0. Cite it with

{hypgraph-0.7.8 → hypgraph-0.7.10}/docs/spec.md

@@ -144,6 +144,13 @@ Implementations must derive these, never store them:
   - A replication edge on the run raises the profile according to its `differs`.
   - A result of `kind=cited` is external only if it `cites` a source node.
 - **basis_changed** (decisions): a `based_on` edge whose target's version has moved past the pinned `dst_v`.
+- **written blind** (results): a work order with `blind: true` opens a window at its creation event and closes it at
+  the first release (return or cancel) or withdrawal of any order in its rework chain. A result its assignee
+  created inside the window, and has not revised since it closed, is written blind under that order, provided the
+  assignee had created nothing in the record before the window opened. While the window is open the result is
+  `sealed`. Once it is closed, earlier results whose numbers it repeats are `agrees_blind`, not `restates`.
+- **blind lines** (claims, hypotheses): independent lines whose group contains a result written blind under a
+  closed window.
 
 ## 6. Write rules (normative for writers)
 

{hypgraph-0.7.8 → hypgraph-0.7.10}/pyproject.toml

@@ -46,7 +46,7 @@ path = "src/hypgraph/__init__.py"
 packages = ["src/hypgraph"]
 
 [tool.hatch.build.targets.sdist]
-include = ["src/hypgraph", "tests", "docs", "README.md", "LICENSE", "NOTICE", "CITATION.cff", "AGENTS.md", "CHANGELOG.md"]
+include = ["src/hypgraph", "tests", "docs", "README.md", "DISCLAIMER.md", "LICENSE", "NOTICE", "CITATION.cff", "AGENTS.md", "CHANGELOG.md"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests", "src/hypgraph/__init__.py"]

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

hypgraph-0.7.10/src/hypgraph/blind.py

@@ -0,0 +1,415 @@
+"""
+Blind work orders: a checker measures without seeing the answer it is checking.
+
+A work order issued with ``blind=True`` seals the record from its assignee until the order is returned. While it is
+open, the assignee reads the problem statement (the investigations and questions: what is being found out, never what
+was found) and its own order; everything else other authors wrote — hypotheses and their predictions, results,
+claims, reviews, runs and their code, sources, other orders, other teams' attempts — is sealed: shown as a placeholder,
+left out of search, its numbers scrubbed wherever else they appear.
+
+What the assignee writes inside that window is **written blind**. When the window closes (the order is returned, or
+cancelled), the record compares: a blind result that repeats an earlier result's numbers *agrees blind* with it
+instead of restating it, and a line of support that contains a blind result is counted as a blind line.
+
+The record enforces what it can see:
+
+- at issue: a blind order carries no prediction, asks for a measurement (not a review or a report), goes to an
+  assignee that has written nothing in this record yet, and its objective, method and note quote no number that
+  only the sealed material carries;
+- at read: :func:`view_for` gives the redaction a host applies to everything it returns to a reader while an order
+  is open — the MCP server (``hypgraph mcp``) for its seat's author, HypMesh for every reader but the agent that
+  wrote a node. ``hypgraph serve`` and the Python API read the whole record: a file is only as blind as whoever
+  holds it.
+
+It cannot see reads. A seat that read the record before its order was issued has already seen what is now sealed;
+give a checker its order first.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from . import derive as D
+
+# Numbers as written: 10,000 · 1229 · 0.0371 · -2.5. Not inside words or ids (n-1a2b3c, X12, v2).
+_NUM = re.compile(r"(?<![\w.,])-?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?(?![\w])")
+# A reader may make these requests while sealed; everything else quotes or summarises what other authors wrote.
+READ_ROUTES = frozenset({"investigations", "orders", "order", "resolve", "subgraph", "node", "why", "impact",
+                         "neighborhood", "search", "events", "verify", "profiles", "profile", "references"})
+POST_ROUTES = frozenset({"check_work"})
+# The problem statement every reader keeps. An investigation says what is being found out; a lead whose framing
+# lived in a second investigation had it sealed, and the numbers that define the problem (1,000,000; 23) then read
+# as secrets, so an honest blind order was refused (first live run, 2026-10-30). Don't put answers in them.
+VISIBLE_TYPES = frozenset({"question", "investigation"})
+# A blind order asks for a measurement. A review or a report has to read what it judges.
+BLIND_PREDICATES = frozenset({"run_registered", "result_exists", "claim_made", "within_budget"})
+SEALED = "sealed"
+
+
+def canon(tok: str) -> str:
+    """A number token as compared: no thousands separators, no trailing zeros after the point."""
+    t = tok.replace(",", "")
+    if "." in t:
+        t = t.rstrip("0").rstrip(".")
+    return t or "0"
+
+
+def _significant(t: str) -> bool:
+    """Small whole numbers (0–12) are everywhere — counts, steps, versions — and say nothing on their own."""
+    try:
+        f = float(t)
+    except ValueError:
+        return False
+    return not (f.is_integer() and abs(f) <= 12)
+
+
+def numbers(x: Any) -> set[str]:
+    """Every significant number in a body, from its text and its values."""
+    out: set[str] = set()
+
+    def walk(v: Any) -> None:
+        if isinstance(v, bool) or v is None:
+            return
+        if isinstance(v, (int, float)):
+            t = canon(repr(float(v))) if isinstance(v, float) else str(v)
+            if _significant(t):
+                out.add(t)
+        elif isinstance(v, str):
+            out.update(c for c in (canon(m.group(0)) for m in _NUM.finditer(v)) if _significant(c))
+        elif isinstance(v, dict):
+            for w in v.values():
+                walk(w)
+        elif isinstance(v, (list, tuple)):
+            for w in v:
+                walk(w)
+    walk(x)
+    return out
+
+
+# ── windows: when an order's assignee works blind ──────────────────
+def _is_order(s: D.Snap, i: str) -> bool:
+    n = s.nodes.get(i)
+    return bool(n and n["type"] == "task" and n["body"].get("assignee") and n["body"].get("objective"))
+
+
+def _create_seqs(s: D.Snap) -> dict[str, int]:
+    return {e["ref"]: e["seq"] for e in s.events if e["kind"] == "create"}
+
+
+@dataclass
+class Window:
+    root: str                      # the first order of the chain (a rework keeps its window)
+    orders: list[str]              # every order of the chain, oldest first
+    assignee: str
+    inv: str
+    start: int                     # seq the root was created at
+    end: int | None                # seq of the first release (return or cancel) or withdrawal in the chain
+    sealing: bool                  # the window is open and the chain's current order is open or overdue
+    fresh: bool                    # the assignee had written nothing in this record before the window opened
+
+    def code(self, s: D.Snap) -> str:
+        return s.nodes[self.orders[-1]]["code"]
+
+
+def windows(s: D.Snap) -> list[Window]:
+    """Every blind order chain in the record, with its window. Cached on the snapshot by its head."""
+    hit = getattr(s, "_blind_windows", None)
+    if hit is not None and hit[0] == s.seq:
+        return hit[1]
+    from . import coord
+    roots: dict[str, list[str]] = {}
+    for i, n in s.nodes.items():
+        if _is_order(s, i) and n["body"].get("blind"):
+            roots.setdefault(coord.chain_root(s, i), []).append(i)
+    out: list[Window] = []
+    if roots:
+        created = _create_seqs(s)
+        first_write: dict[str, int] = {}
+        for e in s.events:
+            if e["kind"] == "create" and e["actor"] not in first_write:
+                first_write[e["actor"]] = e["seq"]
+        for root, chain in roots.items():
+            if not s.nodes[root]["body"].get("blind"):
+                continue                               # a rework made blind after a sighted attempt isn't blind
+            chain = sorted(set(chain) | {root}, key=lambda o: created.get(o, 0))
+            members = set(chain)
+            start = created.get(root, 0)
+            end = None
+            for e in s.events:
+                if e["seq"] <= start:
+                    continue
+                if (e["kind"] == "lease_release" and (e["payload"] or {}).get("task") in members) or \
+                        (e["kind"] == "withdraw" and e["ref"] in members):
+                    end = e["seq"]
+                    break
+            who = s.nodes[root]["body"]["assignee"]
+            cur = chain[-1]
+            status = coord.order_status(s, cur)
+            out.append(Window(root, chain, who, s.nodes[root]["inv"], start, end,
+                              sealing=end is None and status in ("open", "overdue"),
+                              fresh=first_write.get(who, start + 1) > start))
+    s._blind_windows = (s.seq, out)
+    return out
+
+
+def written_blind(s: D.Snap) -> dict[str, Window]:
+    """Results the assignee of a blind order wrote inside its window, unrevised since it closed. An assignee that
+    had written in the record before the order is not fresh: nothing it writes counts as blind."""
+    hit = getattr(s, "_blind_results", None)
+    if hit is not None and hit[0] == s.seq:
+        return hit[1]
+    out: dict[str, Window] = {}
+    ws = [w for w in windows(s) if w.fresh]
+    if ws:
+        created = _create_seqs(s)
+        last_rev: dict[str, int] = {}
+        for e in s.events:
+            if e["kind"] == "revise":
+                last_rev[e["ref"]] = e["seq"]
+        for i, n in s.nodes.items():
+            if n["type"] != "result":
+                continue
+            c = created.get(i, 0)
+            for w in ws:
+                if n["created_by"] == w.assignee and c > w.start and (w.end is None or c < w.end) and \
+                        (w.end is None or last_rev.get(i, 0) < w.end):
+                    out[i] = w
+                    break
+    s._blind_results = (s.seq, out)
+    return out
+
+
+def blind_state(s: D.Snap, nid: str) -> dict:
+    """What derive.state adds for blindness: on a result, the order it was written blind under, and once the window
+    closed, the earlier results it agrees with (instead of restating them); on a claim or hypothesis, how many of
+    its independent lines contain a blind result whose window has closed."""
+    n = s.nodes[nid]
+    out: dict = {}
+    wb = written_blind(s)
+    if n["type"] == "result" and nid in wb:
+        w = wb[nid]
+        out["blind"] = w.code(s)
+        if w.end is None:
+            out["sealed"] = True
+    if n["type"] in ("claim", "hypothesis") and wb:
+        closed = {r for r, w in wb.items() if w.end is not None}
+        if closed:
+            k = _blind_lines(s, nid, closed)
+            if k:
+                out["blind_lines"] = k
+    return out
+
+
+def _blind_lines(s: D.Snap, nid: str, blind: set[str]) -> int:
+    lines = [e["src"] for e in D.supporters(s, nid) if not D.fallen(s, e["src"])]
+    groups: list[tuple[set, bool]] = []
+    for x in lines:
+        r = D.roots(s, x)
+        is_blind = x in blind or bool(r & {D.producing_run(s, b) for b in blind if D.producing_run(s, b)}) \
+            or any(b in blind for b in _derived(s, x))
+        merged = [g for g in groups if g[0] & r]
+        for g in merged:
+            groups.remove(g)
+            r = r | g[0]
+            is_blind = is_blind or g[1]
+        groups.append((r, is_blind))
+    return sum(1 for _r, b in groups if b)
+
+
+def _derived(s: D.Snap, x: str, limit: int = 60) -> set[str]:
+    out, stack = set(), [x]
+    while stack and len(out) < limit:
+        y = stack.pop()
+        for e in s.out.get(y, []):
+            if e["rel"] == "derived_from" and e["dst"] not in out:
+                out.add(e["dst"])
+                stack.append(e["dst"])
+    return out
+
+
+# ── what is sealed, and from whom ──────────────────────────────────
+def public(s: D.Snap, n: dict, w: Window) -> bool:
+    """The problem statement every reader keeps: questions and investigations (the order chain is kept apart)."""
+    return n["type"] in VISIBLE_TYPES
+
+
+def scope(s: D.Snap, w: Window) -> set[str]:
+    """What a sealing window hides from its assignee: everything other authors wrote that isn't the problem
+    statement or the order chain."""
+    chain = set(w.orders)
+    return {i for i, n in s.nodes.items()
+            if i not in chain and n["created_by"] != w.assignee and not public(s, n | {"id": i}, w)}
+
+
+@dataclass
+class View:
+    """The redaction for one reader. Empty (``bool(view) is False``) when nothing is sealed from it."""
+    hide: dict[str, str] = field(default_factory=dict)     # node id → the order code that seals it
+    secrets: frozenset = frozenset()                        # numbers only the sealed material carries
+
+    def __bool__(self) -> bool:
+        return bool(self.hide)
+
+    def because(self) -> str:
+        codes = sorted(set(self.hide.values()))
+        return ", ".join(codes)
+
+    def message(self, what: str = "this") -> str:
+        return (f"{what} is sealed while blind work order {self.because()} is open: the record is hidden from its "
+                "checker until the order is returned. Work from the order (my_work) and return it.")
+
+    def allows(self, method: str, head: str) -> bool:
+        return head in (POST_ROUTES if method == "POST" else READ_ROUTES)
+
+    def scrub(self, x: Any) -> Any:
+        """Every number only the sealed material carries, replaced in every string."""
+        if not self.secrets:
+            return x
+        if isinstance(x, str):
+            return _NUM.sub(lambda m: "[sealed]" if canon(m.group(0)) in self.secrets else m.group(0), x)
+        if isinstance(x, dict):
+            return {k: self.scrub(v) for k, v in x.items()}
+        if isinstance(x, list):
+            return [self.scrub(v) for v in x]
+        return x
+
+    def node(self, d: dict) -> dict:
+        """A sealed node as a reader sees it: what it is and where, not what it says."""
+        code = self.hide.get(d.get("id"), "")
+        st = d.get("state") or {}
+        out = {k: d[k] for k in ("id", "type", "code", "inv", "v", "by", "at") if k in d}
+        out |= {"title": f"sealed until {code} is returned", "kind": "", SEALED: code,
+                "state": {"lifecycle": st.get("lifecycle", "active"), SEALED: code,
+                          "sentence": f"sealed until blind work order {code} is returned"}}
+        if "body" in d:
+            out["body"] = {SEALED: f"until {code} is returned"}
+        for k in ("out", "in"):
+            if k in d:
+                out[k] = [self.edge(e) for e in d[k]]
+        return out
+
+    def edge(self, e: dict) -> dict:
+        if e.get("src") in self.hide or e.get("dst") in self.hide:
+            return e | {"why": "", "data": {}}
+        return e
+
+    def event(self, e: dict) -> dict:
+        if e.get("ref") in self.hide:
+            p = e.get("payload") or {}
+            return e | {"payload": {k: p[k] for k in ("type", "code", "inv", "v", "task") if k in p}}
+        return e
+
+    def apply(self, x: Any) -> Any:
+        """Redact a response: sealed nodes become placeholders, edges touching them lose their reasons, events on
+        them lose their payload, and secret numbers are scrubbed everywhere."""
+        if not self:
+            return x
+        return self.scrub(self._walk(x))
+
+    def _walk(self, x: Any) -> Any:
+        if isinstance(x, list):
+            return [self._walk(v) for v in x]
+        if not isinstance(x, dict):
+            return x
+        if x.get("id") in self.hide and ("type" in x or "code" in x or "body" in x):
+            return self.node(x)
+        if "src" in x and "dst" in x and "rel" in x:
+            return self.edge(x)
+        if "seq" in x and "kind" in x and "ref" in x:
+            return self.event(x)
+        return {k: self._walk(v) for k, v in x.items()}
+
+    def search(self, rows: list[dict]) -> list[dict]:
+        """Search results without sealed nodes: a hit on a sealed body says what the body contains."""
+        return [r for r in rows if r.get("id") not in self.hide]
+
+
+def view_for(s: D.Snap, keep: Callable[[str, dict], bool]) -> View:
+    """The redaction for a reader, while any blind order is sealing: every node in a sealing window's scope, except
+    those ``keep(node_id, node)`` says this reader may see (its own). Secret numbers are the ones in hidden bodies
+    that no visible node carries."""
+    hide: dict[str, str] = {}
+    for w in windows(s):
+        if not w.sealing:
+            continue
+        code = w.code(s)
+        for i in scope(s, w):
+            if i not in hide and not keep(i, s.nodes[i]):
+                hide[i] = code
+    if not hide:
+        return View()
+    hidden_nums: set[str] = set()
+    seen_nums: set[str] = set()
+    for i, n in s.nodes.items():
+        (hidden_nums if i in hide else seen_nums).update(numbers(n["body"]))
+    return View(hide, frozenset(hidden_nums - seen_nums))
+
+
+def view_for_author(s: D.Snap, author: str) -> View:
+    """The redaction for an MCP seat writing as ``author``: sealed only while it holds an open blind order, and then
+    everything in that order's scope is hidden from it."""
+    mine = [w for w in windows(s) if w.sealing and w.assignee == author]
+    if not mine:
+        return View()
+    hide: dict[str, str] = {}
+    for w in mine:
+        for i in scope(s, w):
+            hide.setdefault(i, w.code(s))
+    hidden_nums: set[str] = set()
+    seen_nums: set[str] = set()
+    for i, n in s.nodes.items():
+        (hidden_nums if i in hide else seen_nums).update(numbers(n["body"]))
+    return View(hide, frozenset(hidden_nums - seen_nums))
+
+
+def dispatch(g, method: str, path: str, *, query: dict | None = None, body: dict | None = None,
+             keep: Callable[[str, dict], bool] = lambda i, n: False, **kw) -> tuple[int, Any]:
+    """``server.dispatch`` for a reader while blind orders may be open: refused where a route would quote sealed
+    material, redacted everywhere else. ``keep`` says which nodes this reader may see anyway (its own)."""
+    from .server import dispatch as plain
+    s = g.snapshot()
+    if not windows(s):
+        return plain(g, method, path, query=query, body=body, **kw)
+    v = view_for(s, keep)
+    if not v:
+        return plain(g, method, path, query=query, body=body, **kw)
+    parts = [p for p in path.strip("/").split("/") if p]
+    head, arg = (parts[0] if parts else ""), (parts[1] if len(parts) > 1 else "")
+    if method == "POST" and head == "write":
+        status, out = plain(g, method, path, query=query, body=body, **kw)
+        return status, v.apply(out)
+    if not v.allows(method, head):
+        return 409, {"detail": v.message(f"/{head}"), SEALED: v.because()}
+    if head in ("order", "node", "why", "impact", "neighborhood") and arg:
+        try:
+            nid = g.resolve(arg)
+        except Exception:
+            nid = arg
+        if head == "order" and nid in v.hide:
+            return 409, {"detail": v.message(f"order {arg}"), SEALED: v.because()}
+    status, out = plain(g, method, path, query=query, body=body, **kw)
+    if head == "search" and status == 200 and isinstance(out, dict) and isinstance(out.get("results"), list):
+        out = out | {"results": v.search(out["results"])}
+    return status, v.apply(out)
+
+
+def leaks(s: D.Snap, w: Window, texts: list[str]) -> dict[str, list[str]]:
+    """Numbers an order's own text quotes that only the material it would seal carries: number → codes holding it."""
+    hide = scope(s, w)
+    visible: set[str] = set()
+    for i, n in s.nodes.items():
+        if i not in hide:
+            visible |= numbers(n["body"])
+    quoted = numbers(texts) - visible
+    out: dict[str, list[str]] = {}
+    for i in hide:
+        hit = quoted & numbers(s.nodes[i]["body"])
+        for x in hit:
+            out.setdefault(x, []).append(s.nodes[i]["code"] or i)
+    return {k: sorted(v) for k, v in out.items()}
+
+
+__all__ = ["Window", "View", "windows", "written_blind", "blind_state", "scope", "view_for", "view_for_author",
+           "dispatch", "leaks", "numbers", "BLIND_PREDICATES"]