protocol · lksbrssr · Aug 3, 2026 · Jun 29, 2026 · Jun 29, 2026 · Jun 30, 2026
diff --git a/.env.example b/.env.example
@@ -25,3 +25,9 @@ NEXT_PUBLIC_COOKIE_CONSENT=on
 # GraphQL indexer URL for org.plresearch.* records
 # Default: https://api.hi.gainforest.app/graphql
 # INDEXER_URL=http://localhost:4000/graphql
+
+# Metaculus API token — enables live community-forecast readings on the /impact
+# dashboard (e.g. the whole-brain-emulation question). Without it the question
+# is still linked, just without a live number. Create a token at
+# https://www.metaculus.com/accounts/settings/
+# METACULUS_API_TOKEN=
diff --git a/docs/screenshots/README-impact-v2.md b/docs/screenshots/README-impact-v2.md
@@ -0,0 +1,23 @@
+# Impact dashboard — v1 vs v2 (side-by-side)
+
+Screenshots for the stacked PR that adds the acceleration-centered `/impact-v2`
+alongside the unchanged inflection-point `/impact` (PR #29). Captured at ~1280×600.
+
+## v2 — `/impact-v2` (acceleration reframe)
+
+| File | What it shows |
+|---|---|
+| `v2-light-cards.png` / `v2-dark-cards.png` | Field card leads with the **velocity basket**; hand card shows tool → condition → observed movement |
+| `v2-light-sensors.png` / `v2-dark-sensors.png` | "Our sensors: inflection points" list with status chips (incl. **RETIRED**, illustrative-draft caption) |
+| `v2-light-sensor-modal.png` | **Retired** sensor modal — status + logged post-mortem |
+| `v2-dark-sensor-modal.png` | **Missed · field moved** sensor modal — distinct amber post-mortem |
+| `v2-dark-toolkit.png` | Methodology: the seven-tool toolkit with `releases:` tags + "needs co-funders" markers |
+| `v2-dark-toolkit-modal.png` | Toolkit modal (Culture) — full description + what-changed + co-funder gap |
+| `v2-light-howtoread-modal.png` | How-to-read v2 — X→Y contract + two-axis legend + five sensor-status legend |
+
+## v1 — `/impact` (unchanged from PR #29)
+
+| File | What it shows |
+|---|---|
+| `v1-light-cards.png` / `v1-dark-cards.png` | Original inflection-point cards (The field / Our hand / Live signal) |
+| `v1-light-modal.png` / `v1-dark-modal.png` | Original stacked grey-card detail modal |
diff --git a/docs/screenshots/impact-methodology-interventions-dark.png b/docs/screenshots/impact-methodology-interventions-dark.png
diff --git a/docs/screenshots/impact-methodology-interventions-light.png b/docs/screenshots/impact-methodology-interventions-light.png
diff --git a/docs/screenshots/impact-modal-restructured.png b/docs/screenshots/impact-modal-restructured.png
diff --git a/docs/screenshots/impact-signals-grid.png b/docs/screenshots/impact-signals-grid.png
diff --git a/docs/screenshots/impact-signals-livebar.png b/docs/screenshots/impact-signals-livebar.png
diff --git a/docs/screenshots/impact-signals-modal.png b/docs/screenshots/impact-signals-modal.png
diff --git a/docs/screenshots/impact-signals-platforms.png b/docs/screenshots/impact-signals-platforms.png
diff --git a/docs/screenshots/inflection-card-dark.png b/docs/screenshots/inflection-card-dark.png
diff --git a/docs/screenshots/inflection-card-light.png b/docs/screenshots/inflection-card-light.png
diff --git a/docs/screenshots/methodology-idea-vintage-modal.png b/docs/screenshots/methodology-idea-vintage-modal.png
diff --git a/docs/screenshots/methodology-inflection-quadrant-modal.png b/docs/screenshots/methodology-inflection-quadrant-modal.png
diff --git a/docs/screenshots/v1-dark-cards.png b/docs/screenshots/v1-dark-cards.png
diff --git a/docs/screenshots/v1-dark-modal.png b/docs/screenshots/v1-dark-modal.png
diff --git a/docs/screenshots/v1-light-cards.png b/docs/screenshots/v1-light-cards.png
diff --git a/docs/screenshots/v1-light-modal.png b/docs/screenshots/v1-light-modal.png
diff --git a/docs/screenshots/v2-dark-cards.png b/docs/screenshots/v2-dark-cards.png
diff --git a/docs/screenshots/v2-dark-sensor-modal.png b/docs/screenshots/v2-dark-sensor-modal.png
diff --git a/docs/screenshots/v2-dark-sensors.png b/docs/screenshots/v2-dark-sensors.png
diff --git a/docs/screenshots/v2-dark-toolkit-modal.png b/docs/screenshots/v2-dark-toolkit-modal.png
diff --git a/docs/screenshots/v2-dark-toolkit.png b/docs/screenshots/v2-dark-toolkit.png
diff --git a/docs/screenshots/v2-light-cards.png b/docs/screenshots/v2-light-cards.png
diff --git a/docs/screenshots/v2-light-howtoread-modal.png b/docs/screenshots/v2-light-howtoread-modal.png
diff --git a/docs/screenshots/v2-light-sensor-modal.png b/docs/screenshots/v2-light-sensor-modal.png
diff --git a/docs/screenshots/v2-light-sensors.png b/docs/screenshots/v2-light-sensors.png
diff --git a/docs/screenshots/velocity-box-openalex-dark.png b/docs/screenshots/velocity-box-openalex-dark.png
diff --git a/docs/screenshots/velocity-box-openalex-light.png b/docs/screenshots/velocity-box-openalex-light.png
diff --git a/docs/screenshots/velocity-modal-dark.png b/docs/screenshots/velocity-modal-dark.png
diff --git a/docs/screenshots/velocity-modal-light.png b/docs/screenshots/velocity-modal-light.png
diff --git a/package.json b/package.json
@@ -7,7 +7,8 @@
     "dev": "node scripts/build-content.mjs && next dev",
     "build": "node scripts/build-content.mjs && next build",
     "start": "next start",
-    "generate-jwk": "node scripts/generate-jwk.js"
+    "generate-jwk": "node scripts/generate-jwk.js",
+    "test": "node --test scripts/velocity/*.test.mjs"
   },
   "dependencies": {
     "@atproto/api": "^0.18.17",

diff --git a/scripts/velocity/README.md b/scripts/velocity/README.md
@@ -0,0 +1,23 @@
+# scripts/velocity
+
+The OpenAlex generator and the direction math for the field-velocity
+**idea vintage** instrument.
+
+- `field_velocity_openalex.py` — queries OpenAlex and writes one CSV per focus
+  area into `src/data/velocity/`. **This file is added unchanged from Lukas's
+  working copy; it is not reconstructed here.** Run it yourself only if you have
+  network access and an email to pass:
+
+  ```
+  python scripts/velocity/field_velocity_openalex.py \
+    --search "content addressing|peer-to-peer network|censorship resistance|decentralized storage" \
+    --from-year 2005 --email you@example.org \
+    --out src/data/velocity/digital-human-rights.csv
+  ```
+
+  See `src/data/velocity/README.md` for the CSV contract and the frozen query
+  strings per focus area.
+
+- `vintage-direction.mjs` — the pure, inverted-direction helper. Falling median
+  reference age = accelerating. Imported by the TS ingestion lib and by the test.
+- `vintage-direction.test.mjs` — run with `npm test` (`node --test`).
diff --git a/scripts/velocity/field_velocity_openalex.py b/scripts/velocity/field_velocity_openalex.py
@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""
+field_velocity_openalex.py — build one field-velocity CSV per focus area from
+OpenAlex (CC0). Real data only; no synthesised values.
+
+Per publication year Y it emits:
+  year,field_works,all_works,corpus_share_per_100k,first_time_authors,
+  idea_vintage_median_years,vintage_ci_lo,vintage_ci_hi,n_refs_sampled,reliable
+
+Idea vintage = the median AGE of the references cited by new work in year Y,
+where age = Y - (referenced work's publication year). We draw a random sample of
+works per year (OpenAlex `sample`), resolve their referenced works' years in
+batches, pool the ages, take the median, and bootstrap a 95% CI.
+
+Recent years (>= reliable_cutoff_year) are undercounted by OpenAlex indexing lag
+and are flagged reliable=0.
+
+Queries hit the FILTER cluster (`filter=title_and_abstract.search:...`), not the
+anonymous fulltext `search=` cluster, which is currently rate-limited. `|` ORs
+the frozen terms. A free API key (--api-key) lifts rate limits but is optional.
+
+Usage:
+  python scripts/velocity/field_velocity_openalex.py \
+    --search "content addressing|peer-to-peer network|censorship resistance|decentralized storage" \
+    --from-year 2005 --email lukas@protocol.ai \
+    --out src/data/velocity/digital-human-rights.csv
+"""
+import argparse
+import datetime as dt
+import json
+import random
+import ssl
+import statistics
+import sys
+import time
+import urllib.parse
+import urllib.request
+
+API = "https://api.openalex.org/works"
+
+
+def ssl_context(insecure=False):
+    if insecure:
+        return ssl._create_unverified_context()  # noqa: S323 — only for broken CA envs
+    try:
+        import certifi
+
+        return ssl.create_default_context(cafile=certifi.where())
+    except Exception:  # noqa: BLE001
+        return ssl.create_default_context()
+
+
+SSL_CTX = ssl.create_default_context()
+
+
+def build_url(params):
+    return API + "?" + urllib.parse.urlencode(params, safe="|:,")
+
+
+def fetch(params, email, api_key, tries=6):
+    params = dict(params)
+    if email:
+        params["mailto"] = email
+    if api_key:
+        params["api_key"] = api_key
+    url = build_url(params)
+    delay = 2.0
+    for attempt in range(tries):
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": f"plrd-field-velocity (mailto:{email})"})
+            with urllib.request.urlopen(req, timeout=60, context=SSL_CTX) as r:
+                return json.load(r)
+        except urllib.error.HTTPError as e:
+            if e.code in (429, 503, 500, 502, 504):
+                retry = e.headers.get("retryAfter") or e.headers.get("Retry-After")
+                # Cap the wait: anonymous search can hand back multi-hour backoffs.
+                # Fail fast instead of sleeping for hours; use an API key to lift limits.
+                wait = min(float(retry) + 1 if retry else delay, 120.0)
+                print(f"  … {e.code}, waiting {wait:.0f}s (attempt {attempt+1})", file=sys.stderr)
+                time.sleep(wait)
+                delay = min(delay * 2, 60)
+                continue
+            raise
+        except Exception as ex:  # noqa: BLE001
+            print(f"  … {ex}, retrying (attempt {attempt+1})", file=sys.stderr)
+            time.sleep(delay)
+            delay = min(delay * 2, 60)
+    raise RuntimeError(f"failed after {tries} attempts: {url}")
+
+
+def count(filt, email, api_key):
+    d = fetch({"filter": filt, "per-page": 1}, email, api_key)
+    return d["meta"]["count"]
+
+
+def resolve_ref_years(ref_ids, email, api_key, batch=50):
+    years = {}
+    for i in range(0, len(ref_ids), batch):
+        chunk = ref_ids[i : i + batch]
+        d = fetch(
+            {"filter": "openalex_id:" + "|".join(chunk), "select": "id,publication_year", "per-page": batch},
+            email,
+            api_key,
+        )
+        for w in d.get("results", []):
+            wid = w["id"].split("/")[-1]
+            if w.get("publication_year"):
+                years[wid] = w["publication_year"]
+        time.sleep(0.2)
+    return years
+
+
+def bootstrap_ci(ages, iters=500):
+    if len(ages) < 8:
+        return (None, None)
+    rng = random.Random(42)
+    meds = []
+    n = len(ages)
+    for _ in range(iters):
+        sample = [ages[rng.randrange(n)] for _ in range(n)]
+        meds.append(statistics.median(sample))
+    meds.sort()
+    return (round(meds[int(0.025 * iters)], 2), round(meds[int(0.975 * iters)], 2))
+
+
+def year_row(year, search, all_works, works_per_year, max_refs, email, api_key):
+    field_filt = f"title_and_abstract.search:{search},publication_year:{year}"
+    field_works = count(field_filt, email, api_key)
+    corpus_share = round(field_works / all_works * 1e5, 3) if all_works else 0.0
+
+    # Random sample of works this year, with their references + authors.
+    d = fetch(
+        {
+            "filter": field_filt,
+            "sample": min(works_per_year, max(field_works, 1)),
+            "seed": 42,
+            "per-page": min(works_per_year, 200),
+            "select": "id,publication_year,referenced_works",
+            "mailto": email,
+        },
+        email,
+        api_key,
+    )
+    works = d.get("results", [])
+
+    ref_ids = []
+    for w in works:
+        refs = [r.split("/")[-1] for r in (w.get("referenced_works") or [])]
+        ref_ids += refs[:max_refs]
+    ref_ids = list(dict.fromkeys(ref_ids))  # dedupe, keep order
+
+    ref_years = resolve_ref_years(ref_ids, email, api_key) if ref_ids else {}
+    ages = [year - y for y in ref_years.values() if y and 1900 <= y <= year]
+    median = round(statistics.median(ages), 2) if ages else None
+    lo, hi = bootstrap_ci(ages) if ages else (None, None)
+
+    return {
+        "year": year,
+        "field_works": field_works,
+        "all_works": all_works,
+        "corpus_share_per_100k": corpus_share,
+        "idea_vintage_median_years": median,
+        "vintage_ci_lo": lo,
+        "vintage_ci_hi": hi,
+        "n_refs_sampled": len(ages),
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--search", required=True, help="frozen query, | = OR")
+    ap.add_argument("--from-year", type=int, required=True)
+    ap.add_argument("--to-year", type=int, default=dt.date.today().year)
+    ap.add_argument("--email", default="")
+    ap.add_argument("--api-key", default="")
+    ap.add_argument("--works-per-year", type=int, default=120)
+    ap.add_argument("--max-refs-per-work", type=int, default=60)
+    ap.add_argument("--reliable-cutoff-year", type=int, default=dt.date.today().year - 2)
+    ap.add_argument("--insecure", action="store_true", help="skip TLS verification (broken CA bundles only)")
+    ap.add_argument("--out", required=True)
+    a = ap.parse_args()
+
+    global SSL_CTX
+    SSL_CTX = ssl_context(a.insecure)
+
+    all_works_by_year = {}
+    rows = []
+    for year in range(a.from_year, a.to_year + 1):
+        if year not in all_works_by_year:
+            all_works_by_year[year] = count(f"publication_year:{year}", a.email, a.api_key)
+        print(f"[{year}] querying…", file=sys.stderr)
+        row = year_row(year, a.search, all_works_by_year[year], a.works_per_year, a.max_refs_per_work, a.email, a.api_key)
+        # first_time_authors is left blank: a robust population-level count needs
+        # per-author first-in-field history (not a constant-size sample), so we do
+        # not emit a biased proxy. idea vintage is the wired signal here.
+        row["first_time_authors"] = ""
+        row["reliable"] = 0 if year >= a.reliable_cutoff_year else 1
+        rows.append(row)
+        print(
+            f"    field_works={row['field_works']} median={row['idea_vintage_median_years']} "
+            f"n_refs={row['n_refs_sampled']}",
+            file=sys.stderr,
+        )
+
+    generated = dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds")
+    header = (
+        "year,field_works,all_works,corpus_share_per_100k,first_time_authors,"
+        "idea_vintage_median_years,vintage_ci_lo,vintage_ci_hi,n_refs_sampled,reliable"
+    )
+    lines = [
+        f"# generated: {generated}",
+        "# source: OpenAlex (https://openalex.org, CC0)",
+        f"# query: {a.search}",
+        f"# from_year: {a.from_year}",
+        f"# reliable_cutoff_year: {a.reliable_cutoff_year}",
+        f"# sample: works_per_year={a.works_per_year}; max_refs_per_work={a.max_refs_per_work}; "
+        "cluster=title_and_abstract.search; note=first_time_authors intentionally blank (needs per-author history)",
+        header,
+    ]
+
+    def cell(v):
+        return "" if v is None else str(v)
+
+    for r in rows:
+        lines.append(
+            ",".join(
+                cell(r[k])
+                for k in [
+                    "year",
+                    "field_works",
+                    "all_works",
+                    "corpus_share_per_100k",
+                    "first_time_authors",
+                    "idea_vintage_median_years",
+                    "vintage_ci_lo",
+                    "vintage_ci_hi",
+                    "n_refs_sampled",
+                    "reliable",
+                ]
+            )
+        )
+    with open(a.out, "w") as f:
+        f.write("\n".join(lines) + "\n")
+    print(f"wrote {a.out} ({len(rows)} rows)", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/velocity/vintage-direction.mjs b/scripts/velocity/vintage-direction.mjs
@@ -0,0 +1,64 @@
+// Direction math for the idea-vintage instrument.
+//
+// The sign is INVERTED for this instrument: a FALLING median reference age means
+// new work is building on fresher ideas, i.e. the field is ACCELERATING.
+//
+// The series is a noisy sampled estimate, so we do NOT read a single-year slope
+// or two raw endpoints (those contradict each other and over-claim). Instead we
+// compare the MEAN of the earliest few reliable years against the MEAN of the
+// most recent few, and only call a direction when the shift clears a flat band
+// (roughly the size of the sampling scatter). The dashboard's comparison text
+// and the direction chip are both derived from this one calculation, so they can
+// never disagree.
+//
+// Pure ES module (no TypeScript, no deps) so it can be imported by both the
+// Next build (via the TS ingestion lib) and `node --test`.
+
+/** Least-squares slope (y per unit x), used for rising-is-good count series. */
+export function trailingSlope(points, window = 5) {
+  const pts = points.slice(-window)
+  const n = pts.length
+  if (n < 2) return null
+  let sx = 0
+  let sy = 0
+  let sxx = 0
+  let sxy = 0
+  for (const p of pts) {
+    sx += p.x
+    sy += p.y
+    sxx += p.x * p.x
+    sxy += p.x * p.y
+  }
+  const denom = n * sxx - sx * sx
+  if (denom === 0) return null
+  return (n * sxy - sx * sy) / denom
+}
+
+/** Mean of the earliest and most recent `w` reliable points (sorted ascending). */
+export function windowMeans(points, w = 3) {
+  if (!points.length) return null
+  const k = Math.min(w, points.length)
+  const mean = (arr) => arr.reduce((s, p) => s + p.y, 0) / arr.length
+  const early = points.slice(0, k)
+  const late = points.slice(-k)
+  return {
+    early: mean(early),
+    late: mean(late),
+    earlyRange: [early[0].x, early[early.length - 1].x],
+    lateRange: [late[0].x, late[late.length - 1].x],
+  }
+}
+
+/**
+ * Direction of the idea-vintage instrument from reliable points only.
+ * `flat` is the band (in median-years) within which we call it flat rather than
+ * claim a trend. Returns 'accelerating' | 'flat' | 'decelerating' | 'unclear'.
+ */
+export function ideaVintageDirection(reliablePoints, { w = 3, flat = 0.75 } = {}) {
+  if (!reliablePoints || reliablePoints.length < 2) return 'unclear'
+  const m = windowMeans(reliablePoints, w)
+  if (!m) return 'unclear'
+  const delta = m.late - m.early // rising reference age = older ideas
+  if (Math.abs(delta) <= flat) return 'flat'
+  return delta < 0 ? 'accelerating' : 'decelerating' // falling age (inverted) = accelerating
+}