hypgraph 0.6.0__tar.gz → 0.7.1__tar.gz

{hypgraph-0.6.0 → hypgraph-0.7.1}/.gitignore

@@ -15,5 +15,5 @@ research.hypgraph*
 Thumbs.db
 .claude/
 
-# study runs: outputs, sealed keys and records stay local until published on purpose
-studies/*/runs/
+# internal studies: kept on the machine that runs them, not published
+studies/

{hypgraph-0.6.0 → hypgraph-0.7.1}/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## 0.7.1 — 2026-10-27: a computed answer needs its code, and opposed answers keep a question open
+
+- **A computation nobody can re-run doesn't settle a computational question.** The optimization workflow's
+  `solved`, trading's `backtested` and the scientific workflow's evidenced stage (`result_exists` under a
+  scientific profile) count only results something can re-run: the run that produced them carries its code, or
+  it is the instrument's (`kind=lab`). Through the hypswarm CLI, with no tool that executes code, the seats wrote
+  "exact DP over capacity" and "brute force over 2^21" as prose; the verifier passed a wrong optimum (757 for
+  656) and the question settled. The gate now says which results report a computation with no code behind it.
+  `workflow.rerunnable(snap, result)`.
+- **A question settles only when every live answer to it is checked.** A checked answer beside a live unchecked one
+  used to settle the question, and the two may disagree: in a real-model trading run a reviewer re-ran the numbers
+  behind "no look-ahead" and checked it while "it is look-ahead" stood unchecked on the same question. The board row
+  now says `answered` with the unchecked answers named (`unchecked`), the reviewed gate names them, and completion
+  waits. An answer nobody may review (its author is the only reviewer) doesn't block; the row lists it under
+  `unreviewable`. `derive.unchecked_answers` / `unreviewable_answers`.
+- **Measuring returns isn't trading them.** Trading's BACKTEST_WITHOUT_COSTS no longer fires on a result that counts
+  its returns (`n_returns`, `insample_n_returns`, a value in units of returns, days, bars or trades) or reports a
+  statistic of them (an autocorrelation, its t, p, standard error or CI). A return, P&L or Sharpe still needs its
+  costs. A real-model run lost eight writes measuring a lag-1 autocorrelation.
+- **A confidence interval that excludes zero isn't an exclusion.** "Excludes zero", "excludes 1" (a ratio's
+  null) and "rules out chance" say an effect is there, so they no longer need a power check
+  (EXCLUSION_WITHOUT_POWER). "Rules out an effect" and "no effect" still do.
+
+## 0.7.0 — 2026-10-27: measure questions, and claim checks that know a version from a figure
+
+- **Measure questions.** A question may say `asks: "measure"`, and its workflow's `measure_skips` gates then don't
+  apply to it, in `Graph.stage()` and as order predicates. Until now every question met every gate of its profile:
+  a timing question was reworked for a diff, a count for a preregistered hypothesis, a look-ahead check for a
+  backtest. Real-model runs lost most of their calls to those reworks. `profiles.view()` lists the skipped gates.
+- **Claim checks:** dotted versions, inline code and labels (case 8, cases 9–12, #3) aren't figures; a measurement's
+  key written in place of its number is refused (KEY_FOR_NUMBER); a statement that says nothing ("Placeholder.")
+  is refused (STATEMENT_EMPTY).
+- **A rework's predicates are checked like an order's:** an unknown predicate is refused, naming every predicate the
+  target can take. A lead had reworked an order with an invented one (`claim_answers_q3`) that could never be met.
+- **Trading: a statistic about returns isn't a return earned.** Correlations, hit rates and other diagnostics of
+  returns no longer need fees and slippage (BACKTEST_WITHOUT_COSTS); a return, P&L or Sharpe still does.
+- **hypgraph.com in the app's design system.** One stylesheet on the HypGraph app's tokens and components, light by
+  default, restyles every page. The new homepage:
+  - opens on the live app, which can switch between the five workflows, Broad Street and the page's own record;
+  - offers the agent and engineer paths, then the facts, what the record refuses, the eight rules and the
+    arithmetic of never;
+  - ends with the workflows, the deployment options, the page's record and what the record shows and doesn't claim.
+- **The homepage proves its figures with its own HypGraph record** (`dev/site_record.py`, now run at every deploy):
+  - The instrument measures each figure: tests passing, runtime dependencies, the example records' chains, the bound
+    behind the arithmetic of never, and the refused overclaims.
+  - A reviewer re-measures each one another way.
+  - The page's text is checked against the record with `hypgraph check`, and a copy error fails the deploy.
+- **The report check no longer flags "not ruled out" as an absence claim.** Exclusion words that the sentence negates
+  are skipped, as absolutes already were. "Up to 58,155 … are not ruled out" and "a leak cannot be ruled out" are
+  hedges; the engine's own bound note says it in those words.
+
+- **Derivation scales with the record.** Working out which earlier results a result repeats (`derive.restates`) took a
+  pass over the whole graph for every result, recomputing each one's numbers, so deriving a record grew with the
+  square of its results. It now reads a per-snapshot index of each investigation's results by the numbers they carry,
+  and a result's numbers are computed once per version, shared across snapshots. On `dev/bench.py`'s record: 10,001
+  nodes derive in 0.34 s (was 20.35 s), 4,001 in 0.11 s (was 3.65 s). The write-time duplicate check uses the same
+  index.
+- **Two fixes to carried standing.** Both were found by the test at scale.
+  - Results written in the same second were ordered by id, so a result written later could count as "earlier" and
+    change what an older result repeats, after the older one's standing had been derived and carried forward. Ties now
+    go by write order.
+  - Revising or withdrawing a result now re-derives the results that repeat its numbers. They reach it through no
+    edge, so they used to keep their old standing.
+
+  The randomized incremental suite now gives results numbers, by several authors, and revises them. It fails on the
+  old code (5 of 6 seeds) and passes now.
+- `dev/bench.py`: reads, writes and derivation at a given record size, on your machine. The README's performance
+  figures come from it.
+
 ## 0.6.0 — 2026-10-26: the HypGraph UI, live swarm observability, an example per profile
 
 The Atlas becomes **HypGraph**: one app for every profile, in each profile's own words, that watches a swarm

{hypgraph-0.6.0 → hypgraph-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.6.0
+Version: 0.7.1
 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/
@@ -222,22 +222,23 @@ Or watch a swarm work in each profile, replayed live from its record:
 
 ## Where it came from
 
-HypGraph is the research graph of PegasusDMZ, where a team of AI agents runs long investigations under governed
-egress, pulled out so anyone can use it. Each rule exists because the agents made the mistake behind it:
+HypGraph began as the research graph of a team of AI agents running long investigations under governed egress, and
+was pulled out so anyone can use it. Each rule exists because the agents made the mistake behind it:
 - a validation that was blind to the answer;
 - a null model that broke the system's own rules;
 - a summary whose numbers matched no result;
 - "never" written about something that happened once in a thousand.
 
-PegasusDMZ is the reference deployment, and its graph UI is built from this package. Against PegasusDMZ's live record
-(1,357 events, 790 nodes), the library derives the same standing for every node as the engine it replaced.
+That team still runs on it, and its graph UI is built from this package. Against the team's live record (1,357 events,
+790 nodes), the library derives the same standing for every node as the engine it replaced.
 
 ## Performance
 
-The engine is pure Python and stays fast at the sizes research records reach. At 10,000 nodes, deriving every node's
-standing takes 0.09 s, reading one node 0.3 ms, and a write about 10 ms, mostly SQLite committing to disk. A write
-costs what it touches: cached standing is kept for every node the write can't affect, and a randomized suite checks
-that against a full rebuild.
+The engine is pure Python and stays fast at the sizes research records reach. On `dev/bench.py`'s record (one
+investigation of questions, results, claims and reviews), at 10,001 nodes deriving every node's standing takes 0.34 s
+on a Windows laptop, reading one node 0.07 ms, and a write about 12 ms, mostly SQLite committing to disk; derivation
+grows in step with the record. A write costs what it touches: cached standing is kept for every node the write can't
+affect, and a randomized suite checks that against a full rebuild. Run `python dev/bench.py` for your machine.
 
 ## Made by
 

{hypgraph-0.6.0 → hypgraph-0.7.1}/README.md

@@ -190,22 +190,23 @@ Or watch a swarm work in each profile, replayed live from its record:
 
 ## Where it came from
 
-HypGraph is the research graph of PegasusDMZ, where a team of AI agents runs long investigations under governed
-egress, pulled out so anyone can use it. Each rule exists because the agents made the mistake behind it:
+HypGraph began as the research graph of a team of AI agents running long investigations under governed egress, and
+was pulled out so anyone can use it. Each rule exists because the agents made the mistake behind it:
 - a validation that was blind to the answer;
 - a null model that broke the system's own rules;
 - a summary whose numbers matched no result;
 - "never" written about something that happened once in a thousand.
 
-PegasusDMZ is the reference deployment, and its graph UI is built from this package. Against PegasusDMZ's live record
-(1,357 events, 790 nodes), the library derives the same standing for every node as the engine it replaced.
+That team still runs on it, and its graph UI is built from this package. Against the team's live record (1,357 events,
+790 nodes), the library derives the same standing for every node as the engine it replaced.
 
 ## Performance
 
-The engine is pure Python and stays fast at the sizes research records reach. At 10,000 nodes, deriving every node's
-standing takes 0.09 s, reading one node 0.3 ms, and a write about 10 ms, mostly SQLite committing to disk. A write
-costs what it touches: cached standing is kept for every node the write can't affect, and a randomized suite checks
-that against a full rebuild.
+The engine is pure Python and stays fast at the sizes research records reach. On `dev/bench.py`'s record (one
+investigation of questions, results, claims and reviews), at 10,001 nodes deriving every node's standing takes 0.34 s
+on a Windows laptop, reading one node 0.07 ms, and a write about 12 ms, mostly SQLite committing to disk; derivation
+grows in step with the record. A write costs what it touches: cached standing is kept for every node the write can't
+affect, and a randomized suite checks that against a full rebuild. Run `python dev/bench.py` for your machine.
 
 ## Made by
 

{hypgraph-0.6.0 → hypgraph-0.7.1}/docs/profile-workflows-plan.md

@@ -25,8 +25,8 @@ exists only as a paragraph in the profile's notes and as a diagram on hypswarm.c
 | suggested seats | the **report**: every profile prints "Facts from the research graph" |
 | | the **order**: HypSwarm issues from the question board, not from the stage a question is in |
 
-The discovery study (HypSwarm `studies/discovery/`) showed what this costs: 110 of 118 refusals were vocabulary
-friction because the models were writing discipline work into scientific slots, and the honesty rules by themselves
+An internal study showed what this costs: most refusals were vocabulary
+friction, because the models were writing discipline work into scientific slots, and the honesty rules by themselves
 did not beat a prompt. What a prompt cannot do is remember that the code changed since the tests ran, that the
 source was retracted, that the regime moved, that the teammate's number is stale — the workflow's *invalidation*
 and *gates*. That is where the record should win, and it is exactly what profiles don't yet encode.
@@ -95,7 +95,7 @@ instrument, mechanical feasibility recomputation (P3). **P2 built in HypSwarm 0.
 orders, review on the node the previous gate produced, the record's word on done; the examples' scripted models walk
 the stages; the discovery stub run through its stages). P2 fed back into hypgraph 0.5.1: honest endings the stages
 lacked (a declined thesis, an inconclusive answer, a verified failure), artifacts that learn their kind on
-re-registration, optimization's `checked` stage. **P3 built (2026-10-26):** the instruments in HypSwarm 0.1.0a5 (world watcher, re-verification, source re-fetch, refresh orders) and hypgraph 0.5.2 (source freshness, fresh-only gates, stale in the report); the change suite in HypSwarm `studies/discovery/PLAN-CHANGE.md`, self-test and stub run at $0, predictions locked; the model run waits for the spend approval.
+re-registration, optimization's `checked` stage. **P3 built (2026-10-26):** the instruments in HypSwarm 0.1.0a5 (world watcher, re-verification, source re-fetch, refresh orders) and hypgraph 0.5.2 (source freshness, fresh-only gates, stale in the report); the change suite (an internal study), self-test and stub run at $0, predictions locked; the model run waits for the spend approval.
 
 ## 4. What stays as it is, on purpose
 

hypgraph-0.7.1/docs/site-plan.md

@@ -0,0 +1,116 @@
+# hypgraph.com and hypswarm.com — plan
+
+*Status (2026-10-27): P0 (this plan, the prototype) and P1 (the derivation fix) done; P2 built — hypgraph.com's
+homepage and stylesheet are the design below, and the homepage's record (`dev/site_record.py`) is built at every
+deploy. The prototype folder was retired once the real page replaced it (its screenshots are in the PR that added
+it). P3 (docs, trust page, refusal catalogue) and P4 (hypswarm.com) are next.*
+
+## 1. Where it stands
+
+The HypGraph UI (0.6) reads as a product: a verified chain, counts, states, a run replaying. The two sites read as
+landing pages: a dark neon theme, an animated graph behind the hero, a gradient headline and cards of copy. The copy
+itself is honest — a scan of both homepages found no overclaims — so the gap is presentation, not substance. A
+visitor who clicks from the site into an example also crosses from one visual world into another.
+
+What enterprise readers trust, in roughly this order: the product shown working, specifics they can check, docs with
+depth, a page saying what the thing guarantees and what it doesn't, and restraint. Decoration and adjectives count
+against a tool whose whole pitch is evidence.
+
+## 2. The principle: the site follows the record's rules
+
+HypGraph refuses a number no result accounts for and an "always" without the counts. The sites meet the same bar,
+and prove it with a HypGraph record of their own:
+
+- **Every figure on the page is a claim in the page's record** (`dev/site_record.py`), bound to the measurement it
+  came from. The build's instrument (`lab`) runs the measurements: the test suite, the pyproject, the example
+  bundles' hash chains, and the overclaims the page shows, written into a scratch record.
+- **A reviewer re-measures each one another way** (`site-check`): the suite run again and its tests counted by
+  collection, the pyproject parsed with `tomllib` instead of a regex, the bundles verified by the UI's JavaScript
+  verifier (`dev/js_verify.js`, WebCrypto) instead of the Python one, the overclaims written into a second fresh
+  record. Its verdict goes into the record: replicated, checked, or an objection.
+- **The page's text is linted against the record** with `hypgraph check`: with the figures filled in, a number no
+  claim or result accounts for, an absolute word with nothing behind it, or a citation the record doesn't hold, is
+  an error and fails the build. Words the page quotes as examples of what gets refused are marked `data-quote`; a
+  phrase true by the engine's design ("on every read": standing is derived on read) is marked `data-ok="<why>"` and
+  listed on the page with its reason.
+- **The record ships with the page**, as a bundle a visitor opens in the app on the page ("This page's own record")
+  or verifies themselves.
+
+### What building the record found already
+
+- **The README's performance sentence doesn't hold** on the record shape `dev/bench.py` builds (new: nothing in the
+  repo reproduced the figure before). The profile points to `derive.restates`, which compares each result with every
+  other result in its investigation and recomputes each one's numbers every time. That is an engine fix of its own
+  (P1), now in its own PR: 10,001 nodes derive in 0.34 s (was 20.35 s), and the README quotes the measured figures.
+  The fix also found two bugs in carried standing that the randomized suite had never exercised.
+- The record holds its builders to the same rules: the benchmark's own first writes were refused (a number in a
+  claim bound to nothing; a result repeating another's numbers), and the copy check failed the prototype's first
+  draft three times ("never set by an agent", "what the record guarantees", and a bare 256 in "SHA-256"). Each was
+  fixed: reworded, put in code, or marked true by design with its reason.
+- The derived standing caught a wiring mistake in the builder: the first claims carried `derived_from` but no
+  `supports` link, so each read "no live support · unverified report". With the support link, each reads "checked ·
+  1 independent line of support · lab-recorded run · no external replication" — which is what the page can honestly
+  say, and the page shows it as it is.
+
+## 3. One design system, the app's
+
+The site takes the app's tokens and components (`src/hypgraph/ui/hypgraph.css`): the same colours, type, cards,
+pills, tables and focus rings; light by default and dark one click away; text at WCAG AA in both themes (the
+existing contrast test extends to the site's tokens); motion only where it carries meaning (a run replaying),
+switched off under reduced motion. One header pattern across hypgraph.com and hypswarm.com, each linking the other.
+
+## 4. hypgraph.com
+
+Navigation: Product · Workflows · What it refuses · Docs · Trust · GitHub, plus the version and a copyable
+`pip install hypgraph`.
+
+The homepage, top to bottom (all in the prototype):
+
+| section | shows | backed by |
+|---|---|---|
+| Hero | one plain sentence on what it is; the slogan, smaller | — |
+| The product, live | the app replaying a run; a switch between the five workflows and **this page's own record**; the chain verified on load | the example bundles; the page's record |
+| Facts | tests passing, runtime dependencies, bundles verified in your browser (a button runs it) | each a claim in the page's record, with its review; click to open it |
+| What it refuses | three overclaims, the engine's refusal (codes and text) and the rewrite it accepted | generated at build, a claim in the record |
+| This page has a record | the claims with their reviews, the copy check's result, the phrases true by design | the record and `hypgraph check` |
+| Workflows | the five profiles: stages, what each refuses, when done; each with its live example | the profiles (`hypgraph profiles`) |
+| For the people who deploy agents | MCP + skill, Python, UI and API, CI gate, bundles, HypSwarm | the CLI as it is |
+| Trust | what the record shows and what it doesn't claim; local, no account, no network calls of its own; trusted publishing | the spec and the release workflow |
+
+Other pages: Docs (getting started, concepts, workflows, CLI, Python and HTTP API, MCP, the spec — generated from
+markdown by `dev/build_site.py`, no new dependencies), Trust (the long form of the section, including the bundle
+threat model: scoped bundles, telemetry outside the chain), the refusal catalogue (every code with a real refusal and
+its fix), and the existing Never, Playground, Verify and Examples pages, restyled.
+
+## 5. What we say and what we don't
+
+**We say** what the record checks, what it refused, what was measured (with where), and what it shows.
+Something the product doesn't do well yet stays off the sites until it does; it isn't dressed up.
+
+**We don't say** anything we haven't shown: that teams coordinated through the record beat a well-prompted single
+agent, or cost less; customer logos, testimonials, "trusted by", ROI figures, adjectives such as "enterprise-grade",
+pricing tiers or "contact sales". A short "what it doesn't claim" list sits on the homepage: it doesn't make a
+claim true, and it doesn't make a model reason better.
+
+## 6. hypswarm.com
+
+The same system, a sister site. The hero is the Live view of a swarm working. Then a free scripted quickstart; the
+framework bridges named only where tests cover them (LangChain, PydanticAI, CrewAI, Bedrock); telemetry and
+OpenTelemetry; "alpha" kept visible. It gets a record of its own the same way (its test suite, its examples
+settling, the bridges' tests).
+
+## 7. Phases
+
+| phase | what | verified by |
+|---|---|---|
+| **P0** | this plan, the prototype homepage, the page's record (`dev/site_record.py`), `dev/bench.py` | screenshots in #17; the record builds with 0 copy errors |
+| **P1** | the engine fix for `derive.restates`, measured with `dev/bench.py` (its own PR) | a test at scale; the benchmark |
+| **P2** | the shared design system and the new hypgraph.com homepage, with its record built in CI | the smoke check, the contrast test, the copy check failing the build |
+| **P3** | docs, the trust page, the refusal catalogue | the same |
+| **P4** | hypswarm.com on the same system, with its record | the same |
+
+## 8. Decisions taken
+
+1. No deployment is named on the sites.
+2. Timing stays off the sites until the engine fix lands; nothing the product doesn't do well yet is shown.
+3. The slogan stays as a small tagline under the headline, which says what the product does.

{hypgraph-0.6.0 → hypgraph-0.7.1}/docs/spec.md

@@ -231,4 +231,4 @@ the writer's assertion. Codes are matched within the investigation being reporte
 | warning | `REPORT_CAUSAL_UNCITED` | causal language with no node cited |
 | note | `REPORT_BOUND` | an absolute backed by a cited count: what the count supports |
 
-Calibrated on 24 real write-ups from PegasusDMZ against its live record.
+Calibrated on 24 real write-ups checked against the live record they report on.

{hypgraph-0.6.0 → hypgraph-0.7.1}/docs/workflows/README.md

@@ -15,6 +15,10 @@ Conventions used in every spec:
   AT RISK. Today only the scientific set (`requires`, `derived_from`, `based_on`, `works_on`, `rests_on`) does.
 - **Fresh** says when a result still speaks for the thing it measured.
 - **Typed artifacts** are `artifact` / `source` / `decision` nodes with required fields per `kind`, not new types.
+- **A measure question skips what it doesn't need.** A question with `asks: "measure"` (a rate, a count, a timing, a
+  check of the data or the code as it is) skips the gates its workflow lists in `measure_skips`, in the stage and
+  as an order predicate: scientific skips the hypothesis and preregistration; software the diff and the suite on a
+  new head; trading the thesis, preregistration, backtest and position. The run, result, claim and review stay.
 
 | spec | method it is taken from | the one gate a prompt can't keep |
 |---|---|---|

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

{hypgraph-0.6.0 → hypgraph-0.7.1}/src/hypgraph/checks.py

@@ -4,6 +4,7 @@ and each refusal does the arithmetic the writer skipped, then offers the honest
 
   code                          refused when
   ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
+  STATEMENT_EMPTY               the statement says nothing ("Placeholder.", "TBD", one word)
   SCOPE_MISSING                 a finding or exclusion doesn't say under which conditions it holds
   EVIDENCE_MISSING              nothing supports it
   MEASUREMENT_MALFORMED         a measurement doesn't name its result and field
@@ -11,6 +12,7 @@ and each refusal does the arithmetic the writer skipped, then offers the honest
   MEASUREMENT_MISMATCH          the measurement says a different number from its result
   UNBOUND_NUMBER                a number in the statement comes from nowhere: not a bound measurement, nothing
                                 computed from them (difference, ratio, percentage, interval), the scope or a constant
+  KEY_FOR_NUMBER                the statement names a bound measurement's key (case8_expected) in place of its value
   ABSOLUTE_WITHOUT_COUNT        "never" / "always" / "eliminates" / "100%" with no count of 0 or n behind it
                                 (an absolute over a set the sentence enumerates — "all three subsets: …" — is
                                 not a generalisation and is left alone)
@@ -48,6 +50,13 @@ _WORDS = {w: i for i, w in enumerate("two three four five six seven eight nine t
                                      "fifteen sixteen seventeen eighteen nineteen twenty".split(), start=2)}
 _WORDNUM = re.compile(r"\b(" + "|".join(_WORDS) + r")\b", re.I)   # 'one' is left out: too common as a pronoun
 _LABEL = re.compile(r"""(['"`‘“])[0-9][0-9 ]{0,30}(['"`’”])""")
+# identifiers that look like numbers but aren't measurements: a version (1.10.0, v2.0.0-rc.1), inline code, a number a
+# label word names ("case 8", "cases 9–12", "test 4", "line 12", "#3"), or one that labels the literal after it ("9 ('')")
+_NOT_A_FIGURE = re.compile(
+    r"`[^`\n]*`|(?<![\w.])v?\d+(?:\.\d+){2,}(?:[-+][0-9A-Za-z.]+)?(?![\w])"
+    r"|\b(?:cases?|tests?|lines?|steps?|items?|rows?|issues?|sections?|rules?|figures?|tables?|questions?|no\.)\s+"
+    r"\d+(?:\s*(?:[–-]|to|and|,)\s*\d+)*\b"
+    r"|#\d+\b|(?<![\w.])\d+(?=\s*\(\s*['\"‘“`])", re.I)
 UNDERPOWERED = 0.05             # an absolute needs its 95% bound on the opposite rate at or below this
 _CONVENTIONS = re.compile(r"\b(interval|confidence|CI|bounds?|power|alpha|α|significan\w*|level)\b", re.I)
 
@@ -67,13 +76,15 @@ class Problem:
 
 
 def numbers(text: str) -> list[tuple[float, int, bool, str]]:
-    """(value, decimals printed, is_percent, as printed) for each number in a text."""
+    """(value, decimals printed, is_percent, as printed) for each number in a text. Versions and inline code are
+    identifiers, not figures, and are skipped."""
     out = []
-    for m in _NUM.finditer(text or ""):
+    text = _NOT_A_FIGURE.sub(" ", text or "")
+    for m in _NUM.finditer(text):
         whole, frac, pct = m.group(1), m.group(2), m.group(3)
         v = float(whole.replace(",", "") + ("." + frac if frac else ""))
         out.append((v, len(frac or ""), bool(pct), m.group(0).strip()))
-    for m in _WORDNUM.finditer(text or ""):
+    for m in _WORDNUM.finditer(text):
         out.append((float(_WORDS[m.group(1).lower()]), 0, False, m.group(0)))
     return out
 
@@ -390,6 +401,10 @@ def _exclusion(s: Snap, stmt: str, kind: str, support: list[str], bound: list) -
                     "effect", words=words)]
 
 
+_PLACEHOLDER = re.compile(r"^\W*(?:(?:placeholder|tbd|todo|tba|n/?a|none|wip|xxx|test|claim|statement|pending|"
+                          r"to be (?:determined|confirmed|added)|lorem ipsum)\W*)+$", re.I)
+
+
 def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Problem]:
     """What's wrong with a claim, each with a code, a message and a fix (empty = it may enter the record).
     ``support``: ids of the nodes that support it or that it is derived from."""
@@ -400,6 +415,10 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
     if invb.get("strict_claims") is False:
         return []
     problems: list[Problem] = []
+    if _PLACEHOLDER.match(stmt) or len(re.findall(r"[^\W\d_]{3,}", stmt)) < 2:
+        # a claim written to clear a gate (studies/challenges E2: "Placeholder.", contested and left in the record)
+        problems.append(Problem("STATEMENT_EMPTY", "the statement says nothing: write the finding itself — what was "
+                                "measured, on what, and what it came to"))
     if kind in ("finding", "exclusion") and len(scope.strip()) < 10:
         problems.append(Problem("SCOPE_MISSING", "scope: say under which conditions this holds (the data, method, "
                                 "sample) — at least a sentence"))
@@ -427,6 +446,13 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
                                 "investigation's constants account for: " + ", ".join(p[3] for p in loose[:8])
                                 + " — bind them to result fields (measurements) or move design constants into the "
                                 "scope", fix="bind each number to a result field", words=[p[3] for p in loose[:8]]))
+    keys = {str(m.get("key") or "") for m in body.get("measurements") or [] if isinstance(m, dict)}
+    named = [k for k in sorted(keys) if ("_" in k or any(ch.isdigit() for ch in k)) and len(k) >= 4
+             and re.search(rf"(?<![\w`]){re.escape(k)}(?![\w`])", stmt)]
+    if named:
+        problems.append(Problem("KEY_FOR_NUMBER", "the statement names a measurement's key instead of saying its value: "
+                                + ", ".join(named[:6]) + " — write the number in the sentence; it's bound to that key, "
+                                "so the record checks it", fix="replace each key with its number", words=named[:6]))
     problems += _absolutes(clean, scope, body, bound)
     if kind not in ("lead", "convention"):
         problems += _comparisons(s, clean, bound, support)

{hypgraph-0.6.0 → hypgraph-0.7.1}/src/hypgraph/coord.py

@@ -340,6 +340,15 @@ def _done_text(pred: dict, target_type: str = "") -> str:
 
 
 # ── issuing and settling ──────────────────────────────────────────
+def _known_predicates(preds: list[dict]) -> None:
+    """Refuse a predicate the record can't evaluate: an order carrying one can never be met."""
+    from .graph import GraphError
+    bad = [p["p"] for p in preds if p["p"] not in PREDICATES and p["p"] not in profiles.PRED_DESC]
+    if bad:
+        raise GraphError(f"unknown predicate(s) {bad}: write each as {{\"p\": \"claim_made\"}}; predicates: "
+                         + ", ".join(sorted(set(PREDICATES) | set(profiles.PRED_DESC))))
+
+
 def issue_work(g: "Graph", *, author: str, inv: str, target: str, assignee: str, objective: str, role: str = "",
                done_when: list | None = None, prediction: str = "", method: str = "", budget: dict | None = None,
                premises: list | None = None, lease_minutes: int = 240, note: str = "") -> dict:
@@ -367,10 +376,7 @@ def issue_work(g: "Graph", *, author: str, inv: str, target: str, assignee: str,
         raise GraphError(f"{lease['agent']} holds {_code(s, t)} until {lease['expires']}")
     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"}]))]
-    bad = [p["p"] for p in preds if p["p"] not in PREDICATES and p["p"] not in profiles.PRED_DESC]
-    if bad:
-        raise GraphError(f"unknown predicate(s) {bad}: write each as {{\"p\": \"claim_made\"}}; predicates: "
-                         + ", ".join(PREDICATES))
+    _known_predicates(preds)
     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":
@@ -476,6 +482,8 @@ def rework(g: "Graph", *, author: str, order: str, missing: str, done_when: list
                          "unmeetable as tooled. Change it (rework with done_when=…), accept what was delivered with a "
                          "reason (accept_work needs every predicate met — so change it first), or cancel_work.")
     done_when = [norm_pred(x) for x in done_when] if done_when else None
+    if done_when:                       # a lead reworked with 'claim_answers_q3', an order nothing could meet (S1)
+        _known_predicates(done_when)
     prem = [e["dst"] for e in premises_of(s, order)]
     fields = {"objective": objective or b["objective"], "assignee": b["assignee"], "role": b.get("role", ""),
               "done_when": done_when or b.get("done_when") or [], "prediction": b.get("prediction", ""),
@@ -721,7 +729,13 @@ def question_board(g: "Graph", inv: str) -> list[dict]:
         checked = [c for c in ans if states[c] == "checked"]
         contested = [c for c in ans if states[c] == "contested"]
         o = open_orders.get(q)
-        if checked:
+        pending = D.unchecked_answers(s, q)
+        if checked and pending:
+            # two live answers, one checked: settled only once every live answer is checked (they may disagree)
+            status, by = "answered", (f"{', '.join(_code(s, c) for c in pending[:3])} unchecked beside "
+                                      f"{_code(s, checked[0])} (checked) — review it, or withdraw the wrong answer"
+                                      + (f"; order {o['code']} on it" if o else ""))
+        elif checked:
             status, by = "settled", f"{_code(s, checked[0])} (checked by " + ", ".join(
                 x.split(":")[0] for x in D.state(s, checked[0])["review"]["positive"][:2]) + ")"
         elif contested:
@@ -733,7 +747,8 @@ def question_board(g: "Graph", inv: str) -> list[dict]:
         else:
             status, by = "open", ""
         rows.append({"id": q, "code": n["code"], "text": _title(s, q), "status": status, "by": by,
-                     "answers": [_code(s, c) for c in ans]})
+                     "answers": [_code(s, c) for c in ans], "unchecked": [_code(s, c) for c in pending],
+                     "unreviewable": [_code(s, c) for c in D.unreviewable_answers(s, q)]})
     return rows
 
 

{hypgraph-0.6.0 → hypgraph-0.7.1}/src/hypgraph/derive.py

@@ -41,6 +41,10 @@ class Snap:
         self.withdrawn: dict[str, dict] = {}
         self.leases: dict[str, dict] = {}
         self._state: dict[str, dict] = {}
+        # result signatures by node (keyed on the body they were taken from, so a later snapshot can share them),
+        # and per investigation an index of its live results by the numbers they carry — built on first use
+        self._sigs: dict[str, tuple] = {}
+        self._results: dict[str, tuple] = {}
         self.sig: Any = None
         self.versions: dict[str, list] = defaultdict(list)
         self.events: list[dict] = []
@@ -233,6 +237,30 @@ def _moved_since(s: Snap, rid: str) -> list[str]:
     return out
 
 
+def _open_answers(s: Snap, q: str) -> list[str]:
+    return [e["src"] for e in s.inn.get(q, []) if e["rel"] == "answers" and s.nodes[e["src"]]["type"] == "claim"
+            and lifecycle(s, e["src"]) == "active" and not fallen(s, e["src"]) and not stale(s, e["src"])
+            and (state(s, e["src"]).get("review") or {}).get("state") != "checked"]
+
+
+def reviewable(s: Snap, nid: str) -> bool:
+    """Someone besides its author (and the curators) may review it."""
+    return bool(board(s, nid) - set(s.policy.curators) - {s.nodes[nid]["created_by"]})
+
+
+def unchecked_answers(s: Snap, q: str) -> list[str]:
+    """Live, fresh claims answering question ``q`` that no reviewer has checked and one could. A question settles only
+    when this is empty: a checked answer beside a live unchecked one is two answers the record hasn't reconciled, and
+    they may disagree (studies T1: "no look-ahead" checked while "is look-ahead" stood unchecked on the same
+    question). An answer nobody may review (its author is the only reviewer) can't block it; ``unreviewable_answers``
+    lists those."""
+    return [c for c in _open_answers(s, q) if reviewable(s, c)]
+
+
+def unreviewable_answers(s: Snap, q: str) -> list[str]:
+    return [c for c in _open_answers(s, q) if not reviewable(s, c)]
+
+
 def stale(s: Snap, nid: str) -> list[str]:
     """Why a result (or a claim through its results) no longer speaks for what it measured; [] when fresh. A result
     is stale when the run that produced it used an artifact that is now superseded or withdrawn, or when its
@@ -448,29 +476,70 @@ def result_signature(body: dict) -> tuple | None:
     return tuple(sorted(nums))
 
 
-def restates(s: Snap, nid: str) -> list[str]:
-    """Earlier live results in the same investigation whose numbers this result repeats (the same multiset, or a
-    subset of it): one measurement written twice is one line of evidence, however many times it is written."""
+def signature_of(s: Snap, nid: str) -> tuple | None:
+    """result_signature of a node's current body, computed once per body. Keyed on the body object itself (held, so
+    its identity can't be reused): a revision brings a new body, and so does a write that re-stages one."""
     n = s.nodes[nid]
+    hit = s._sigs.get(nid)
+    if hit is not None and hit[0] is n["body"]:
+        return hit[1]
     sig = result_signature(n["body"])
-    if not sig:
-        return []
-    mine = sorted(sig)
+    s._sigs[nid] = (n["body"], sig)
+    return sig
+
+
+def result_index(s: Snap, inv: str) -> tuple[dict, dict]:
+    """The investigation's results: (number → the live results carrying it, result → (created_at, its position in
+    the graph)). Built once per snapshot, so checking every result costs what the matches cost, not one pass over
+    the graph each. The position is write order, so it breaks ties within a second."""
+    idx = s._results.get(inv)
+    if idx is None:
+        by_num: dict[float, set] = defaultdict(set)
+        order: dict[str, tuple] = {}
+        for pos, (i, m) in enumerate(s.nodes.items()):
+            if m["type"] != "result" or m["inv"] != inv:
+                continue
+            order[i] = (m["created_at"], pos)
+            sig = None if i in s.withdrawn else signature_of(s, i)
+            for x in set(sig or ()):
+                by_num[x].add(i)
+        idx = s._results[inv] = (by_num, order)
+    return idx
+
+
+def repeating(s: Snap, sig: tuple, inv: str) -> list[str]:
+    """Live results in the investigation whose numbers contain all of ``sig`` (as a multiset), in graph order."""
+    by_num, order = result_index(s, inv)
+    cands: set | None = None
+    for x in set(sig):
+        ids = by_num.get(x)
+        if not ids:
+            return []
+        cands = set(ids) if cands is None else cands & ids
+        if not cands:
+            return []
     out = []
-    for i, m in s.nodes.items():
-        if i == nid or m["type"] != "result" or m["inv"] != n["inv"] or i in s.withdrawn:
-            continue
-        if (m["created_at"], i) >= (n["created_at"], nid):
-            continue
-        other = result_signature(m["body"])
-        if not other:
-            continue
-        pool = list(other)
-        if all(_take(pool, x) for x in mine):
+    for i in sorted(cands or (), key=lambda i: order[i][1]):
+        pool = list(signature_of(s, i) or ())
+        if all(_take(pool, x) for x in sig):
             out.append(i)
     return out
 
 
+def restates(s: Snap, nid: str) -> list[str]:
+    """Earlier live results in the same investigation whose numbers this result repeats (the same multiset, or a
+    subset of it): one measurement written twice is one line of evidence, however many times it is written.
+    Earlier is by created_at, then by write order — never by id, which would let a result written later count as
+    earlier and change what an older result restates, after its standing was derived and carried forward."""
+    n = s.nodes[nid]
+    sig = signature_of(s, nid)
+    if not sig:
+        return []
+    _, order = result_index(s, n["inv"])
+    mine = order[nid]
+    return [i for i in repeating(s, sig, n["inv"]) if i != nid and order[i] < mine]
+
+
 def _take(pool: list, x: float) -> bool:
     try:
         pool.remove(x)
@@ -549,6 +618,14 @@ def affected_by(s: Snap, touched: set) -> set:
                 run = producing_run(s, i)
                 if not (run and any(e["rel"] == "uses" for e in s.out.get(run, []))):
                     stack.append(i)
+    # a result reaches, through no edge, the results that repeat its numbers (see restates): revising or withdrawing
+    # it can change what they restate. Every version's numbers count — the results that repeated the old ones too.
+    for x in [x for x in stack if s.nodes[x]["type"] == "result"]:
+        by_num, _ = result_index(s, s.nodes[x]["inv"])
+        nums = {v for ver in s.versions.get(x, ()) for v in (result_signature(ver["body"]) or ())}
+        nums |= set(signature_of(s, x) or ())
+        for v in nums:
+            stack += [i for i in by_num.get(v, ()) if i != x]
     while stack:
         y = stack.pop()
         if y in out: