hypgraph 0.7.9__tar.gz → 0.7.11__tar.gz

{hypgraph-0.7.9 → hypgraph-0.7.11}/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## 0.7.11 — 2026-10-30: a sealed checker can't learn the answer by asking
+
+An adversarial test on a local HypMesh planted a 5-digit reading and 12-digit tags in a lead's sealed nodes and
+attacked every route as the blind checker. Nothing leaked directly, but the checker could tell a right guess from a
+wrong one, and 60 requests recovered the reading exactly. Fixed:
+
+- **Errors no longer mark a right guess.** Answers scrubbed only the numbers the sealed material carries, so a route
+  that echoes its input (`resolve`, `node`, `why`, `order`, `check_work`, a refused write) answered "no node
+  '[sealed]'" for a right guess and "no node '48220'" for a wrong one. While a reader is sealed, every number in an
+  error is now blanked, secret or not; the MCP seat does the same.
+- **A write is answered with the view after it.** The checker's own new numbers were scrubbed with the view from
+  before the write, so a result carrying the right reading came back "[sealed]".
+- **No check reads sealed material for a sealed writer.** A claim bound to the sealed result was refused with an
+  unbound number for a wrong guess and passed that check for the right one, and the auto-bind looked the guess up
+  in the sealed results without any id given. A sealed writer may now link to a sealed node only to say its own work
+  supports, challenges or tests a hypothesis; binding to, resting on, reviewing, revising or ordering work on sealed
+  nodes is refused with one message before any check runs, and a seat holding a blind order issues no orders.
+  `Graph.sealed_from(hide)` lets a host apply its reader's view to writes, so writing under another name doesn't
+  escape the seal.
+- **The leak check at issue skips what is sealed from the issuer**, which would otherwise answer the issuer's guesses.
+
+`tests/test_blind_oracles.py` asks every request with the right and a wrong guess on fresh records and requires the
+same answer; 14 of its 23 tests fail on 0.7.10.
+
+## 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`

{hypgraph-0.7.9 → hypgraph-0.7.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.9
+Version: 0.7.11
 Summary: The evidence layer for AI research agents: a hash-chained research record that checks every claim as it is written and derives how well each is known.
 Project-URL: Homepage, https://hypgraph.com
 Project-URL: Documentation, https://hypgraph.com/engineers/

{hypgraph-0.7.9 → hypgraph-0.7.11}/docs/spec.md

@@ -162,6 +162,11 @@ Implementations must derive these, never store them:
 - Nobody officially reviews their own node.
 - Writes into an `archived` or `published` investigation are refused (reserved authors excepted).
 - Only the importer may set a write's time. Everyone else's comes from the writer's clock.
+- A writer sealed from nodes (it holds an open blind work order, or a host passes its reader's view with
+  `Graph.sealed_from`) may link to a sealed node only to say its own work `supports`, `challenges` or `tests` a
+  hypothesis. It may not bind a measurement to a sealed result, rest a claim on sealed work, review or revise a sealed
+  node, or issue a work order on sealed work, and a seat holding a blind order issues no orders. These are refused
+  with one message, before any check reads the sealed material, so that no answer depends on what is sealed.
 
 ## 7. Claim checks
 

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

{hypgraph-0.7.9 → hypgraph-0.7.11}/src/hypgraph/blind.py

@@ -2,8 +2,8 @@
 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 investigation the order belongs to, the curators' investigations,
-the questions) and its own order; everything else other authors wrote — hypotheses and their predictions, results,
+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.
 
@@ -21,6 +21,11 @@ The record enforces what it can see:
   wrote a node. ``hypgraph serve`` and the Python API read the whole record: a file is only as blind as whoever
   holds it.
 
+A sealed reader can't learn what is sealed by asking either: an error that echoes its request has every number
+blanked (not only the secret ones, which would mark a right guess), a write is answered with the view after it, and a
+sealed writer's writes may not rest on sealed nodes, so no check reads them on its behalf (``graph.sealed_from``).
+``tests/test_blind_oracles.py`` asks every request with a right and a wrong guess and requires the same answer.
+
 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.
 """
@@ -39,7 +44,10 @@ _NUM = re.compile(r"(?<![\w.,])-?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?(?![\w])")
 READ_ROUTES = frozenset({"investigations", "orders", "order", "resolve", "subgraph", "node", "why", "impact",
                          "neighborhood", "search", "events", "verify", "profiles", "profile", "references"})
 POST_ROUTES = frozenset({"check_work"})
-VISIBLE_TYPES = frozenset({"question"})
+# 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"
@@ -228,10 +236,8 @@ def _derived(s: D.Snap, x: str, limit: int = 60) -> set[str]:
 
 # ── what is sealed, and from whom ──────────────────────────────────
 def public(s: D.Snap, n: dict, w: Window) -> bool:
-    """The problem statement every reader keeps: questions, the curators' investigations, the order's own
-    investigation, and the order chain itself."""
-    return (n["type"] in VISIBLE_TYPES
-            or (n["type"] == "investigation" and (n["created_by"] in s.policy.curators or n["id"] == w.inv)))
+    """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]:
@@ -274,6 +280,26 @@ class View:
             return [self.scrub(v) for v in x]
         return x
 
+    def blank(self, x: Any) -> Any:
+        """Every significant number replaced, secret or not: for answers that may echo what the reader sent (errors,
+        refusals). Scrubbing only the secret ones there would mark a right guess as "[sealed]" and leave a wrong one
+        as written — an oracle (an adversarial run found six routes that did, 2026-10-30)."""
+        if not self:
+            return x
+        if isinstance(x, str):
+            return _NUM.sub(lambda m: "[number]" if _significant(canon(m.group(0))) else m.group(0), x)
+        if isinstance(x, dict):
+            return {k: self.blank(v) for k, v in x.items()}
+        if isinstance(x, list):
+            return [self.blank(v) for v in x]
+        return x
+
+    def answer(self, status: int, out: Any) -> Any:
+        """A response as this reader gets it: redacted, and with every number blanked when it is an error."""
+        if not self:
+            return out
+        return self.blank(self._walk(out)) if status >= 400 else self.apply(out)
+
     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"), "")
@@ -377,26 +403,30 @@ def dispatch(g, method: str, path: str, *, query: dict | None = None, body: dict
     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)
+        # the write is checked as this reader: nothing it may not see is read on its behalf (graph.sealed_from); its
+        # answer is redacted with the view after the write, in which its own new numbers are no longer secret
+        with g.sealed_from(v.hide):
+            status, out = plain(g, method, path, query=query, body=body, **kw)
+        return status, (view_for(g.snapshot(), keep) or v).answer(status, out)
     if not v.allows(method, head):
-        return 409, {"detail": v.message(f"/{head}"), SEALED: v.because()}
+        return 409, v.blank({"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()}
+            return 409, v.blank({"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)
+    return status, v.answer(status, 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)
+def leaks(s: D.Snap, w: Window, texts: list[str], skip: dict | set | None = None) -> dict[str, list[str]]:
+    """Numbers an order's own text quotes that only the material it would seal carries: number → codes holding it.
+    ``skip``: material sealed from the issuer, left out (comparing against it would answer the issuer's guesses)."""
+    hide = scope(s, w) - set(skip or ())
     visible: set[str] = set()
     for i, n in s.nodes.items():
         if i not in hide:

{hypgraph-0.7.9 → hypgraph-0.7.11}/src/hypgraph/coord.py

@@ -371,6 +371,11 @@ def issue_work(g: "Graph", *, author: str, inv: str, target: str, assignee: str,
         raise GraphError(str(e).strip("'\"") + " — a target is a code the record has (Q1, H2, X1, CL3; find lists "
                          "them) or the investigation's id; add a hypothesis or experiment first if you need a new "
                          "one") from None
+    from . import blind as B
+    own = B.view_for_author(s, author)
+    if own:                     # a seat holding a blind order measures; it issues orders once it has returned it
+        raise g._sealed(own.hide, "a work order")
+    hidden = g._hidden(s, author)
     if D.out_of_play(s, t):
         raise GraphError(f"{_code(s, t)} is {D.lifecycle(s, t)}{' and fallen' if D.fallen(s, t) else ''} — "
                          "nothing to work on")
@@ -386,9 +391,6 @@ def issue_work(g: "Graph", *, author: str, inv: str, target: str, assignee: str,
     preds = [norm_pred(p) for p in (done_when or profiles.default_done(s, inv, s.nodes[t]["type"])
                                      or DEFAULT_DONE.get(s.nodes[t]["type"], [{"p": "result_exists"}]))]
     _known_predicates(preds)
-    if blind:
-        _blind_ok(s, inv=inv, author=author, assignee=assignee, target=t, preds=preds, prediction=prediction,
-                  texts=[objective, method, note, role])
     if premises is None:
         prem = [a for a, _r, _d in D.ancestors(s, t, limit=40) if s.nodes[a]["type"] not in ("artifact", "task")]
         if s.nodes[t]["type"] == "experiment":
@@ -396,6 +398,11 @@ def issue_work(g: "Graph", *, author: str, inv: str, target: str, assignee: str,
     else:
         prem = prem_ids
     prem = [p for p in dict.fromkeys(prem) if p in s.nodes and p != t][:30]
+    if hidden and (t in hidden or any(p in hidden for p in prem)):     # its text would quote sealed work
+        raise g._sealed(hidden, "a work order on sealed work")
+    if blind:
+        _blind_ok(s, inv=inv, author=author, assignee=assignee, target=t, preds=preds, prediction=prediction,
+                  texts=[objective, method, note, role], skip=hidden)
     fields = {"objective": objective, "assignee": assignee, "role": role, "done_when": preds,
               "prediction": prediction, "method": method, "budget": budget or {}, "note": note,
               "title": objective[:300]}
@@ -410,8 +417,10 @@ def issue_work(g: "Graph", *, author: str, inv: str, target: str, assignee: str,
 
 
 def _blind_ok(s: D.Snap, *, inv: str, author: str, assignee: str, target: str, preds: list[dict], prediction: str,
-              texts: list[str]) -> None:
-    """A blind order's checks at issue: what the record can see of whether the assignee will really work blind."""
+              texts: list[str], skip: dict | None = None) -> None:
+    """A blind order's checks at issue: what the record can see of whether the assignee will really work blind.
+    ``skip``: what is sealed from the issuer itself, left out of the leak check (comparing against it would tell the
+    issuer whether a number it guessed is in there)."""
     from .graph import GraphError
     from . import blind as B
     if prediction.strip():
@@ -431,7 +440,7 @@ def _blind_ok(s: D.Snap, *, inv: str, author: str, assignee: str, target: str, p
         raise GraphError(f"{assignee} has already written in this record ({', '.join(wrote)}), so it has read what a "
                          "blind order would seal. Give the blind order to a seat that hasn't")
     w = B.Window("", [], assignee, inv, s.seq, None, sealing=True, fresh=True)
-    found = B.leaks(s, w, [x for x in texts if x])
+    found = B.leaks(s, w, [x for x in texts if x], skip=skip)
     if found:
         said = "; ".join(f"{k} (in {', '.join(v[:3])})" for k, v in sorted(found.items())[:6])
         raise GraphError(f"the order quotes what it would seal: {said}. Say what to measure and how, not what it "

{hypgraph-0.7.9 → hypgraph-0.7.11}/src/hypgraph/graph.py

@@ -170,6 +170,25 @@ def clean_body(ntype: str, body: dict, *, partial_ok: bool = False) -> dict:
 
 class _Writer(threading.local):
     task = ""
+    hide: Optional[dict] = None
+
+
+class sealed_from:
+    """``with g.sealed_from(hide):`` — the writes inside come from a reader these nodes are sealed from (a host's blind
+    view: node id → the order that seals it, ``blind.view_for(...).hide``). They may not rest on those nodes, and no
+    check reads them on the writer's behalf: a check that did would answer a right guess differently from a wrong one.
+    An author holding a blind order is sealed this way without it; a host passes its reader's view so that writing
+    under another name doesn't escape the seal."""
+    def __init__(self, graph: "Graph", hide: dict | None):
+        self.graph = graph
+        self.hide = dict(hide or {})
+
+    def __enter__(self):
+        self.prev, self.graph._writer.hide = self.graph._writer.hide, self.hide
+        return self
+
+    def __exit__(self, *exc):
+        self.graph._writer.hide = self.prev
 
 
 class writing_for:
@@ -259,6 +278,42 @@ class Graph:
     def writing_for(self, task: str | None) -> writing_for:
         return writing_for(self, task)
 
+    def sealed_from(self, hide: dict | None) -> sealed_from:
+        return sealed_from(self, hide)
+
+    def _hidden(self, s: D.Snap, author: str) -> dict:
+        """What is sealed from this write's author: its own open blind orders' scope, and the host's view if given."""
+        from . import blind
+        out = dict(self._writer.hide or {})
+        for i, c in blind.view_for_author(s, author).hide.items():
+            out.setdefault(i, c)
+        return out
+
+    @staticmethod
+    def _sealed(hidden: dict, what: str) -> GraphError:
+        """The one refusal a sealed writer gets, the same whatever it guessed."""
+        codes = ", ".join(sorted({c for c in hidden.values() if c})) or "a blind work order"
+        return GraphError(f"{what}: that work is sealed from you while {codes} is open, so nothing you write may rest on "
+                          "it or be checked against it. Record your own measurement, return the order (return_work), "
+                          "and build on the rest once it opens.",
+                          [{"code": "SEALED", "message": what}])
+
+    def _sealed_measurements(self, s: D.Snap, hidden: dict, body: dict, inv: str) -> None:
+        for m in body.get("measurements") or []:
+            ref = str(m.get("result") or "") if isinstance(m, dict) else ""
+            hits = [ref] if ref in s.nodes else [i for i, n in s.nodes.items()
+                                                 if ref and n["code"].lower() == ref.lower() and n["inv"] == inv]
+            if any(h in hidden for h in hits):
+                raise self._sealed(hidden, f"a measurement bound to {ref}")
+
+    def _sealed_links(self, s: D.Snap, hidden: dict, links: list[tuple[str, str, str]]) -> None:
+        """A sealed writer's links may reach a sealed node only to say its own work supports, challenges or tests a
+        hypothesis — what a blind order targets; a claim, result or anything else would be read on its behalf."""
+        for a, rel, b in links:
+            for x in (a, b):
+                if x in hidden and not (s.nodes[x]["type"] == "hypothesis" and rel in ("supports", "challenges", "tests")):
+                    raise self._sealed(hidden, f"a {rel} link to {s.nodes[x]['code'] or x}")
+
     def author(self, name: str) -> "Author":
         """A handle that writes as ``name`` — convenient in notebooks and scripts."""
         return Author(self, name)
@@ -707,12 +762,17 @@ class Graph:
                 pending = [(a, rel, b) for a, rel, b, _f in oriented]
                 flipped = [f"{s.nodes[a].get('code') or a} -{rel}-> {s.nodes[b].get('code') or b}"
                            for a, rel, b, f in oriented if f]
+                hidden = self._hidden(s, author)
+                if hidden:
+                    self._sealed_links(s, hidden, pending)
                 for a, rel, b in pending:
                     self._check_link(s, a, rel, b)
                 auto_notes: list[str] = []
                 if type == "claim":
                     body = self._bind_measurements(s, body, inv)
                     staged["body"] = body
+                    if hidden:
+                        self._sealed_measurements(s, hidden, body, inv)
                     # a measurement names the result its number comes from: that result supports the claim, so the
                     # standing counts it as a line of support without a separate link from the writer
                     for m in body.get("measurements") or []:
@@ -729,7 +789,9 @@ class Graph:
                 if type == "claim" and author not in P.curators:
                     problems = claim_issues(s, body, self._support_ids(s, nid, pending), inv)
                     loose = [w for p in problems if p.code == "UNBOUND_NUMBER" for w in p.words]
-                    if loose:                               # repair before refusing: bind what the record holds
+                    # repair before refusing: bind what the record holds — not for a sealed writer, whose numbers
+                    # would be looked up in what is sealed from it
+                    if loose and not hidden:
                         body, extra, auto_notes = self._auto_bind(s, body, inv, who,
                                                                   self._support_ids(s, nid, pending), loose)
                         if auto_notes:
@@ -976,15 +1038,22 @@ class Graph:
                     raise
                 extra: list[str] = []
                 auto_notes: list[str] = []
+                hidden = self._hidden(s, author)
+                if hidden and node in hidden:
+                    raise self._sealed(hidden, f"a revision of {n['code'] or node}")
                 if n["type"] == "claim":
                     body = self._bind_measurements(s, body, n["inv"])
+                    if hidden:
+                        self._sealed_measurements(s, hidden, body, n["inv"])
+                        if set(self._support_ids(s, node, [])) & set(hidden):
+                            raise self._sealed(hidden, f"a revision of {n['code'] or node}, which rests on sealed work")
                 if n["type"] == "run" and body.get("kind") != n["body"].get("kind") and author != P.operator:
                     raise GraphError("a run's kind (lab / agent / external) is where its record came from; it doesn't "
                                      "change")
                 if n["type"] == "claim" and author not in P.curators:
                     problems = claim_issues(s, body, self._support_ids(s, node, []), n["inv"])
                     loose = [w for p in problems if p.code == "UNBOUND_NUMBER" for w in p.words]
-                    if loose:
+                    if loose and not hidden:
                         body, extra, auto_notes = self._auto_bind(s, body, n["inv"], n["created_by"],
                                                                   self._support_ids(s, node, []), loose)
                         if auto_notes:
@@ -1032,6 +1101,13 @@ class Graph:
                 if translated:
                     data = {**(data or {}), "read_as": given}                       # what the author wrote
                 src, rel, dst, flipped = self._orient(s, src, rel, dst)
+                hidden = self._hidden(s, author)
+                if hidden:
+                    self._sealed_links(s, hidden, [(src, rel, dst)])
+                    for x in (src, dst):                     # a claim of its own may not come to rest on sealed work
+                        if x in s.nodes and s.nodes[x]["type"] == "claim" and \
+                                set(self._support_ids(s, x, [(src, rel, dst)])) & set(hidden):
+                            raise self._sealed(hidden, f"a link that rests {s.nodes[x]['code'] or x} on sealed work")
                 if src in s.nodes:
                     self._fixed_guard(s, author, src)
                 eid = self._transaction(lambda con: self._insert_edge(con, s, src, rel, dst, data or {}, why, author,
@@ -1146,6 +1222,9 @@ class Graph:
                     raise GraphError(f"no node {target}")
                 if n["type"] not in RELS["reviews"][1]:
                     raise GraphError(f"a {n['type']} isn't reviewed")
+                hidden = self._hidden(s, author)
+                if hidden and target in hidden:
+                    raise self._sealed(hidden, f"a review of {n['code'] or target}")
                 official = author in D.board(s, target) and verdict != "comment"
                 if official and author == n["created_by"] and author not in P.curators:
                     who = ", ".join(sorted(D.board(s, target) - P.curators - {author})[:6]) or "another reviewer"

{hypgraph-0.7.9 → hypgraph-0.7.11}/src/hypgraph/mcp.py

@@ -186,10 +186,12 @@ def build(graph: Graph | str, author: Optional[str] = None, files_root: str | No
             try:
                 out = fn(*a, **kw)
             except ToolError as e:
-                if v:
-                    raise ToolError(v.scrub(str(e))) from None
+                after = sealed() or v
+                if after:           # every number blanked: scrubbing only the secret ones would mark a right guess
+                    raise ToolError(after.blank(str(e))) from None
                 raise
-            return v.scrub(out) if v and isinstance(out, str) else out
+            after = sealed()        # after a write its own new numbers are no longer secret
+            return after.scrub(out) if after and isinstance(out, str) else out
         return mcp.tool(wrapped)
 
     def fail(e: Exception):
@@ -551,10 +553,12 @@ def build(graph: Graph | str, author: Optional[str] = None, files_root: str | No
 
     @tool
     def my_work(investigation: str = "") -> str:
-        """Your open work orders, each with its full text. An order you have returned is no longer yours to work:
-        it waits for acceptance, and comes back as a new order if it is reworked."""
+        """Your open work orders, each with its full text, in every investigation unless you name one. An order you
+        have returned is no longer yours to work: it waits for acceptance, and comes back as a new order if it is
+        reworked."""
         try:
-            allmine = [o for o in g.orders(inv_of(investigation)) if o["assignee"] == me]
+            invs = [g.resolve(investigation)] if investigation else [i["id"] for i in g.investigations()]
+            allmine = [o for inv in invs for o in g.orders(inv) if o["assignee"] == me]
         except (GraphError, KeyError) as e:
             fail(e)
         mine = [o for o in allmine if o["status"] in ("open", "overdue")]

{hypgraph-0.7.9 → hypgraph-0.7.11}/src/hypgraph/schema.py

@@ -148,6 +148,10 @@ REL_SYNONYMS: dict[str, str] = {
     "correct": "corrects", "corrected": "corrects", "require": "requires", "required": "requires",
     "depends_on": "requires", "part": "part_of", "belongs_to": "part_of", "motivated": "motivated_by",
     "rests": "rests_on", "works": "works_on", "blocked": "blocked_by", "settle": "settles", "settled": "settles",
+    # inverses whose node types fix the direction (a result can't produce a run): turned round by _orient. Not
+    # supported_by / challenged_by: a claim can sit at either end of those.
+    "produced_by": "produced", "generated_by": "produced", "output_of": "produced", "executed_by": "executes",
+    "tested_by": "tests",
 }
 
 SYNONYMS: dict[tuple[str, str], dict[str, str]] = {

{hypgraph-0.7.9 → hypgraph-0.7.11}/src/hypgraph/ui/hypgraph.css

@@ -92,7 +92,7 @@
 .hg.hg-embed .hg-app { height: auto; grid-template-rows: 52px auto; }
 .hg.hg-embed .hg-main, .hg.hg-embed .hg-nav { overflow: visible; }
 .hg.hg-embed .feed { max-height: none; overflow: visible; }
-.hg.hg-embed { overflow: visible; }
+.hg.hg-embed { overflow-x: clip; overflow-y: visible; }   /* the closed drawer sits off to the right: never widen the page */
 .hg .kpi { padding: 12px 14px; } .hg .kpi .k { color: var(--ink2); font-size: 12px; }
 .hg .kpi .v { font-size: 22px; font-weight: 650; letter-spacing: -.02em; margin-top: 2px; font-variant-numeric: tabular-nums; }
 .hg .kpi .s { color: var(--ink3); font-size: 11.5px; margin-top: 2px; }
@@ -247,6 +247,7 @@
   .hg .hg-nav button { width: auto; flex: none; white-space: nowrap; padding: 6px 10px; }
   .hg .hg-nav .n { margin-left: 4px; } .hg .hg-nav .inv .s { display: none; }
   .hg .hg-main { padding: 16px 16px 32px; }
+  .hg.hg-embed .hg-nav { overflow-x: auto; overflow-y: hidden; }   /* beats the embed's overflow: visible: every tab reachable */
   .hg .trace .tr { grid-template-columns: minmax(90px, 40%) minmax(0, 1fr) 48px; }
 }
 @media (prefers-reduced-motion: reduce) { .hg *, .hg *::before { animation: none !important; transition: none !important; } }

{hypgraph-0.7.9 → hypgraph-0.7.11}/tests/test_blind.py

@@ -166,3 +166,49 @@ def test_mcp_seat_holding_a_blind_order(env, tmp_path):
             ov = text(await c.call_tool("overview", {"investigation": inv}))
             assert "Primes below" in ov
     asyncio.run(go())
+
+
+# ── from the first live run (Claude leading, Codex checking on HypMesh, 2026-10-30) ──
+def test_a_framing_investigation_is_the_problem_statement_and_my_work_finds_the_order():
+    fastmcp = pytest.importorskip("fastmcp")
+    from hypgraph.mcp import build
+    g = Graph(clock=Clock())
+    lead = g.author("lead")
+    frame = lead.investigation("The question", "Count the primes below 1,000,000 whose digits sum to 23.")["id"]
+    inv = lead.investigation("Lead's attempt", "Count them, and have the count checked blind.")["id"]
+    h = lead.add("hypothesis", inv, statement="There are 5503 primes below 1,000,000 whose digits sum to 23.",
+                 predictions=["an independent count finds 5503"])["id"]
+    o = g.issue_work(author="lead", inv=inv, target=h, assignee="checker", blind=True,
+                     objective="Count the primes below 1,000,000 whose digits sum to 23, with your own code.")
+    v = B.view_for_author(g.snapshot(), "checker")
+    assert frame not in v.hide and h in v.hide and "5503" in v.secrets and "23" not in v.secrets
+    with pytest.raises(GraphError, match="quotes what it would seal: 5503"):
+        h2 = lead.add("hypothesis", inv, statement="Most of them are below 900,000.",
+                      predictions=["more than half fall below 900,000"])["id"]
+        g.issue_work(author="lead", inv=inv, target=h2, assignee="other", blind=True,
+                     objective="Check that the count is 5503.")
+
+    async def go():
+        async with fastmcp.Client(build(g, author="checker")) as c:
+            r = await c.call_tool("my_work", {})                 # no investigation named, two in the record
+            assert o["code"] in r.content[0].text and "BLIND" in r.content[0].text
+    asyncio.run(go())
+
+
+def test_inverse_relation_words_are_turned_round(env):
+    g, inv, h1, rs1 = env
+    a = g.author("lead")
+    run = a.add("run", inv, kind="agent", name="second sieve", state="succeeded")["id"]
+    rs = a.add("result", inv, summary="The second sieve counts 1230 primes below 10,000; the largest is 9967.",
+               outcome="positive", values={"count": 1230, "largest": 9967},
+               links=[{"rel": "produced_by", "to": run}])
+    assert any(e["rel"] == "produced" and e["src"] == run for e in rs["in"])
+
+
+def test_the_embedded_app_never_widens_its_page():
+    from pathlib import Path
+    import hypgraph.ui as ui
+    css = (Path(ui.__file__).parent / "hypgraph.css").read_text(encoding="utf-8")
+    assert ".hg.hg-embed { overflow-x: clip;" in css
+    narrow = css.split("@container hg (max-width: 760px)", 1)[1].split("\n}\n", 1)[0]
+    assert ".hg.hg-embed .hg-nav { overflow-x: auto;" in narrow

hypgraph-0.7.11/tests/test_blind_oracles.py

@@ -0,0 +1,191 @@
+"""A sealed checker can't learn what is sealed by asking: every request it can make answers the same whether its guess
+of a sealed value is right or wrong (an adversarial test on a live mesh, 2026-10-30, found six routes that marked a
+right guess as "[sealed]", and claim checks that accepted a right guess and refused a wrong one).
+
+Each case runs on its own fresh record twice, once with the sealed reading and once with a wrong one, through
+``blind.dispatch`` as a host serves the checker (its own nodes kept), and the two answers must be identical once the
+guess itself and fresh ids are blanked."""
+import re
+from datetime import datetime, timedelta
+
+import pytest
+
+from hypgraph import Graph, Policy
+from hypgraph import blind as B
+
+R, WRONG = 48213, 48220
+WORD = "quillotine"
+
+
+class Clock:
+    def __init__(self):
+        self.t = datetime(2026, 1, 1, 9, 0, 0)
+
+    def __call__(self):
+        self.t += timedelta(seconds=1)
+        return self.t.isoformat(timespec="seconds")
+
+
+def fixture():
+    """The lead read the instrument (R) and holds it in a hypothesis, a result and a bound claim; the checker has a
+    blind order and its own run."""
+    g = Graph(policy=Policy(reviewers={"critic"}), clock=Clock())
+    lead = g.author("lead")
+    inv = lead.investigation("Read the instrument", "Record the instrument's reading and have it checked blind.")["id"]
+    h1 = lead.add("hypothesis", inv, statement=f"The instrument reads {R}, codeword {WORD}.",
+                  predictions=[f"A second reading gives {R}."])["id"]
+    run = lead.add("run", inv, kind="agent", name=f"read by {WORD}", state="succeeded")["id"]
+    rs1 = lead.add("result", inv, summary=f"The instrument read {R} ({WORD}).", outcome="positive",
+                   values={"reading": R},
+                   links=[{"rel": "produced", "from": run}, {"rel": "supports", "to": h1, "why": "the reading it predicts"}])["id"]
+    lead.add("claim", inv, statement=f"The instrument reads {R}.", kind="finding",
+             scope="One reading of the instrument, taken by the lead.",
+             measurements=[{"result": rs1, "key": "reading"}], links=[{"rel": "supports", "from": rs1, "why": "it measured it"}])
+    o = g.issue_work(author="lead", inv=inv, target="H1", assignee="checker", blind=True,
+                     objective="Take your own reading of the instrument and record it as a result named reading.")
+    mine = g.author("checker").add("run", inv, kind="agent", name="my own reading", state="succeeded")["id"]
+    return g, {"inv": inv, "h1": h1, "rs1": rs1, "run": run, "order": o["order"], "mine": mine}
+
+
+def own(g):
+    return lambda i, n: n["created_by"] == "checker"
+
+
+def ask(g, method, path, body=None, query=None):
+    return B.dispatch(g, method, path, query=query, body=body, keep=own(g), writable=True)
+
+
+def write(g, body):
+    return ask(g, "POST", "/write", {"author": "checker", **body})
+
+
+# every request a checker might make with a guess in it: (name, fn(g, ids, x) -> (status, answer))
+CASES = {
+    "resolve": lambda g, i, x: ask(g, "GET", "/resolve", query={"ref": str(x)}),
+    "node": lambda g, i, x: ask(g, "GET", f"/node/{x}"),
+    "why": lambda g, i, x: ask(g, "GET", f"/why/{x}"),
+    "order": lambda g, i, x: ask(g, "GET", f"/order/{x}"),
+    "search": lambda g, i, x: ask(g, "GET", "/search", query={"text": str(x)}),
+    "check_work text": lambda g, i, x: ask(g, "POST", "/check_work", {"order": i["order"], "text": f"I read {x}."}),
+    "check_work order": lambda g, i, x: ask(g, "POST", "/check_work", {"order": str(x)}),
+    "bad type": lambda g, i, x: write(g, {"op": "create", "type": f"t {x}", "inv": i["inv"], "fields": {}}),
+    "bad field": lambda g, i, x: write(g, {"op": "create", "type": "result", "inv": i["inv"],
+                                           "fields": {"summary": f"read {x}", "outcome": "positive", "zz": f"{x} x"}}),
+    "claim bound to the sealed result": lambda g, i, x: write(g, {
+        "op": "create", "type": "claim", "inv": i["inv"],
+        "fields": {"statement": f"The instrument reads {x}.", "scope": "My reading of the instrument, taken once.",
+                   "kind": "finding", "measurements": [{"result": i["rs1"], "key": "reading"}]},
+        "links": [{"rel": "supports", "from": i["rs1"], "why": "the reading it measured"}]}),
+    "claim with an unbound number": lambda g, i, x: write(g, {
+        "op": "create", "type": "claim", "inv": i["inv"],
+        "fields": {"statement": f"The instrument reads {x}.", "scope": "My reading of the instrument, taken once.",
+                   "kind": "finding"}}),
+    "claim by code": lambda g, i, x: write(g, {
+        "op": "create", "type": "claim", "inv": i["inv"],
+        "fields": {"statement": f"The instrument reads {x}.", "scope": "My reading of the instrument, taken once.",
+                   "kind": "finding", "measurements": [{"result": "RS1", "key": "reading"}]}}),
+    "result supporting the target": lambda g, i, x: write(g, {
+        "op": "create", "type": "result", "inv": i["inv"],
+        "fields": {"summary": f"My reading is {x}.", "outcome": "positive", "values": {"reading": x}},
+        "links": [{"rel": "produced", "from": i["mine"]}, {"rel": "supports", "to": i["h1"], "why": "the reading it predicts"}]}),
+    "result challenging the target": lambda g, i, x: write(g, {
+        "op": "create", "type": "result", "inv": i["inv"],
+        "fields": {"summary": f"My reading is {x}.", "outcome": "positive", "values": {"reading": x}},
+        "links": [{"rel": "produced", "from": i["mine"]}, {"rel": "challenges", "to": i["h1"], "why": "a different reading"}]}),
+    "result replicating the sealed one": lambda g, i, x: write(g, {
+        "op": "create", "type": "result", "inv": i["inv"],
+        "fields": {"summary": f"My reading is {x}.", "outcome": "positive", "values": {"reading": x}},
+        "links": [{"rel": "produced", "from": i["mine"]}, {"rel": "replicates", "to": i["rs1"], "why": "same reading"}]}),
+    "review of the sealed result": lambda g, i, x: write(g, {
+        "op": "review", "target": i["rs1"], "verdict": "pass", "method": "re-read the instrument",
+        "notes": f"I read {x}, the same."}),
+    "review of the target": lambda g, i, x: write(g, {
+        "op": "review", "target": i["h1"], "verdict": "pass", "method": "re-read the instrument",
+        "notes": f"I read {x}, the same."}),
+    "blind order to another seat": lambda g, i, x: write(g, {
+        "op": "issue_work", "inv": i["inv"], "target": i["mine"], "assignee": "third", "blind": True,
+        "objective": f"Check that the instrument reads {x}, with a reading of your own."}),
+    "order on the target": lambda g, i, x: write(g, {
+        "op": "issue_work", "inv": i["inv"], "target": i["h1"], "assignee": "third",
+        "objective": f"Check that the instrument reads {x}, with a reading of your own."}),
+}
+
+
+def run_case(fn, x):
+    g, ids = fixture()
+    status, out = fn(g, ids, x)
+    # the checker's own new node as it then reads it, with its derived state (a right guess must not show there)
+    after = []
+    if status == 200 and isinstance(out, dict) and out.get("id") in g.snapshot().nodes:
+        after = ask(g, "GET", f"/node/{out['id']}")
+    return status, out, after
+
+
+def norm(x, guess):
+    t = repr(x)
+    t = t.replace(f"{guess:,}", "<X>").replace(str(guess), "<X>")
+    t = re.sub(r"\bn[0-9a-f]{12}\b", "<N>", t)
+    t = re.sub(r"\binv-[0-9a-f]{8}\b", "<INV>", t)
+    t = re.sub(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d", "<T>", t)
+    return t
+
+
+@pytest.mark.parametrize("name", list(CASES))
+def test_a_right_guess_answers_like_a_wrong_one(name):
+    right, wrong = run_case(CASES[name], R), run_case(CASES[name], WRONG)
+    assert norm(right, R) == norm(wrong, WRONG), f"{name}: the answer tells a right guess from a wrong one"
+
+
+def test_no_answer_carries_sealed_words():
+    for name, fn in CASES.items():
+        for x in (R, WRONG):
+            assert WORD not in repr(run_case(fn, x)), f"{name} quotes sealed text"
+
+
+def test_a_sealed_checker_still_does_its_work():
+    """The fixes refuse nothing the order needs: a result of its own that supports or tests the target."""
+    for name in ("result supporting the target", "result challenging the target"):
+        status, out, _ = run_case(CASES[name], WRONG)
+        assert status == 200, (name, out)
+
+
+def test_a_host_view_seals_writes_under_another_name():
+    """A host seals by reader (HypMesh: the agent token), and a token may write under several names. The write is
+    checked against the reader's view, so a name with no blind order of its own learns no more."""
+    def as_alias(x):
+        g, i = fixture()
+        return ask(g, "POST", "/write", {"author": "alias", "op": "create", "type": "claim", "inv": i["inv"],
+                                         "fields": {"statement": f"The instrument reads {x}.", "kind": "finding",
+                                                    "scope": "My reading of the instrument, taken once.",
+                                                    "measurements": [{"result": i["rs1"], "key": "reading"}]}})
+    right, wrong = as_alias(R), as_alias(WRONG)
+    assert right[0] == 400 and "sealed from you" in right[1]["detail"]
+    assert norm(right, R) == norm(wrong, WRONG)
+    g, i = fixture()                                  # with no host view, plain hypgraph takes the name at its word
+    with pytest.raises(Exception, match="link the evidence|refused"):
+        g.create(author="alias", type="claim", inv=i["inv"], fields={
+            "statement": f"The instrument reads {WRONG}.", "kind": "finding", "scope": "A reading, taken once.",
+            "measurements": [{"result": i["rs1"], "key": "reading"}]})
+
+
+def test_the_mcp_seat_answers_a_right_guess_like_a_wrong_one(tmp_path):
+    import asyncio
+    fastmcp = pytest.importorskip("fastmcp")
+    from hypgraph.mcp import build
+
+    def seat(x):
+        g, i = fixture()
+        out = []
+
+        async def go():
+            async with fastmcp.Client(build(g, author="checker")) as c:
+                for name, args in (("show", {"node": str(x)}),
+                                   ("add", {"type": "result", "investigation": i["inv"],
+                                            "fields": {"summary": f"My reading is {x}.", "outcome": "positive",
+                                                       "values": {"reading": x}},
+                                            "links": [{"rel": "supports", "to": "H1", "why": "the reading it predicts"}]})):
+                    r = await c.call_tool(name, args, raise_on_error=False)
+                    out.append((r.is_error, r.content[0].text))
+        asyncio.run(go())
+        return out
+    assert norm(seat(R), R) == norm(seat(WRONG), WRONG)